@dotcms/angular 26.8.3-1 → 26.8.3-1-next.2490

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotcms/angular",
-  "version": "26.08.03-01",
+  "version": "26.8.3-1-next.2490",
   "peerDependencies": {
     "rxjs": ">=7.0.0",
     "@angular/common": ">=17.0.0",
@@ -9,8 +9,8 @@
   },
   "dependencies": {
     "@tinymce/tinymce-angular": "9.0.0",
-    "@dotcms/client": "26.08.03-01",
-    "@dotcms/uve": "26.08.03-01",
+    "@dotcms/client": "26.8.3-1-next.2490",
+    "@dotcms/uve": "26.8.3-1-next.2490",
     "tslib": "^2.3.0"
   },
   "description": "Official Angular Components library to render a dotCMS page.",
@@ -34,15 +34,16 @@
   },
   "homepage": "https://github.com/dotCMS/core/tree/main/core-web/libs/sdk/angular/README.md",
   "module": "fesm2022/dotcms-angular.mjs",
-  "typings": "index.d.ts",
+  "typings": "types/dotcms-angular.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./index.d.ts",
+      "types": "./types/dotcms-angular.d.ts",
       "default": "./fesm2022/dotcms-angular.mjs"
     }
   },
-  "sideEffects": false
+  "sideEffects": false,
+  "type": "module"
 }

package/types/dotcms-angular.d.ts

@@ -0,0 +1,484 @@
+import { UVE_MODE, DotCMSClientConfig, DotHttpClient, DotCMSBasicContentlet, BlockEditorNode, BlockEditorMark, DotCMSPageAsset, DotCMSPageRendererMode, DotPageAssetLayoutRow, DotCMSExtendedPageResponse, DotCMSComposedPageResponse } from '@dotcms/types';
+import * as i0 from '@angular/core';
+import { Provider, EnvironmentProviders, OnInit, OnChanges, Type } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { createDotCMSClient } from '@dotcms/client';
+import { EditorComponent } from '@tinymce/tinymce-angular';
+import { BlockEditorState, BlockEditorDefaultBlocks } from '@dotcms/types/internal';
+import { Observable } from 'rxjs';
+
+/**
+ * Directive to show a template when the UVE is in a specific mode.
+ *
+ * @example
+ * <div *dotCMSShowWhen="UVE_MODE.EDIT">
+ *     This will be shown when the UVE is in edit mode.
+ * </div>
+ *
+ * @export
+ * @class DotCMSShowWhenDirective
+ */
+declare class DotCMSShowWhenDirective {
+    #private;
+    set dotCMSShowWhen(value: UVE_MODE);
+    private updateViewContainer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DotCMSShowWhenDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DotCMSShowWhenDirective, "[dotCMSShowWhen]", never, { "dotCMSShowWhen": { "alias": "dotCMSShowWhen"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Provides a DotCMS image loader configuration for the Angular Image directive
+ *
+ * @param path - The base URL path to the DotCMS instance, or empty to use current site
+ * @returns An array of providers for the IMAGE_LOADER token
+ * @throws Error if the provided path is invalid
+ * @example
+ * ```typescript
+ * // In your app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideDotCMSImageLoader('https://demo.dotcms.com')
+ *     // Or use current site:
+ *     // provideDotCMSImageLoader()
+ *   ]
+ * };
+ * ```
+ */
+declare function provideDotCMSImageLoader(path?: string): Provider[];
+
+/**
+ * Type alias for the return type of createDotCMSClient function.
+ * Used to ensure type consistency across the DotCMSClient interface and class.
+ */
+type ClientType = ReturnType<typeof createDotCMSClient>;
+/**
+ * Interface that extends the client type created by createDotCMSClient.
+ * This interface provides type safety and IntelliSense support for the DotCMS client
+ * when used as a dependency injection token in Angular applications.
+ *
+ * @example
+ * ```typescript
+ * dotcmsClient = inject(DotCMSClient);
+ * ```
+ */
+interface DotCMSClient extends ClientType {
+}
+declare class DotCMSClient {
+    constructor(client: ClientType);
+}
+/**
+ * Provides Angular environment providers for the DotCMS client.
+ *
+ * Registers a singleton DotCMS client instance in the Angular dependency injection system,
+ * configured with the given options. This allows you to inject `DotCMSClient` anywhere
+ * in your app using Angular's `inject()` function.
+ *
+ * Should be added to the application's providers (e.g., in `main.ts` or `app.config.ts`).
+ *
+ * @param options - Configuration for the DotCMS client.
+ *   @param options.dotcmsUrl - The base URL for the DotCMS instance (required).
+ *   @param options.authToken - Authentication token for API requests (required).
+ *   @param options.siteId - The site identifier (optional).
+ *   @param options.requestOptions - Additional fetch options (optional).
+ *   @param options.httpClient - Optional factory for a custom HTTP client, receives Angular's HttpClient.
+ * @returns Angular environment providers for the DotCMS client.
+ *
+ * @example
+ * import { provideDotCMSClient } from '@dotcms/angular';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideDotCMSClient({
+ *       dotcmsUrl: 'https://demo.dotcms.com',
+ *       authToken: 'your-auth-token',
+ *       siteId: 'your-site-id',
+ *       httpClient: (http) => new AngularHttpClient(http)
+ *     })
+ *   ]
+ * });
+ */
+declare function provideDotCMSClient(options: DotCMSAngularProviderConfig): EnvironmentProviders;
+/**
+ * Configuration interface for the DotCMS Angular provider.
+ *
+ * Extends the base `DotCMSClientConfig` but replaces the `httpClient` property
+ * with an Angular-specific factory function that receives Angular's `HttpClient`
+ * and returns a `DotHttpClient` implementation.
+ *
+ * This interface is designed to work seamlessly with Angular's dependency injection
+ * system, allowing you to leverage Angular's built-in HTTP client while maintaining
+ * compatibility with the DotCMS client's expected interface.
+ *
+ * @example
+ * ```typescript
+ * const config: DotCMSAngularProviderConfig = {
+ *   dotcmsUrl: 'https://demo.dotcms.com',
+ *   authToken: 'your-auth-token',
+ *   siteId: 'your-site-id',
+ *   httpClient: (http: HttpClient) => new AngularHttpClient(http)
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with provideDotCMSClient
+ * provideDotCMSClient({
+ *   dotcmsUrl: 'https://demo.dotcms.com',
+ *   authToken: 'your-auth-token',
+ *   httpClient: (http) => new AngularHttpClient(http)
+ * })
+ * ```
+ */
+interface DotCMSAngularProviderConfig extends Omit<DotCMSClientConfig, 'httpClient'> {
+    /**
+     * Optional factory function that creates a custom HTTP client implementation.
+     *
+     * This function receives Angular's `HttpClient` instance and should return
+     * a `DotHttpClient` implementation. If not provided, the DotCMS client will
+     * use its default HTTP client implementation.
+     *
+     * @param http - Angular's HttpClient instance from dependency injection
+     * @returns A DotHttpClient implementation
+     *
+     * @example
+     * ```typescript
+     * httpClient: (http: HttpClient) => {
+     *   return new AngularHttpClient(http);
+     * }
+     * ```
+     */
+    httpClient?: (http: HttpClient) => DotHttpClient;
+}
+
+type DOT_EDITABLE_TEXT_MODE = 'minimal' | 'full' | 'plain';
+type DOT_EDITABLE_TEXT_FORMAT = 'html' | 'text';
+
+/** Minimal TinyMCE editor API used by this component (avoids non-portable reference to nested tinymce types). */
+interface DotEditableTextEditor {
+    getContent(options?: {
+        format?: string;
+    }): string;
+    isDirty(): boolean;
+    setContent(content: string, options?: {
+        format?: string;
+    }): void;
+    focus(): void;
+    hasFocus(): boolean;
+}
+/**
+ * Dot editable text component.
+ * This component is responsible to render a text field that can be edited inline.
+ *
+ * @export
+ * @class DotCMSEditableTextComponent
+ * @implements {OnInit}
+ * @implements {OnChanges}
+ */
+declare class DotCMSEditableTextComponent<T extends DotCMSBasicContentlet> implements OnInit, OnChanges {
+    #private;
+    editorComponent: EditorComponent;
+    /**
+     * Represents the mode of the editor which can be `plain`, `minimal`, or `full`
+     *
+     * @type {DOT_EDITABLE_TEXT_MODE}
+     * @memberof DotCMSEditableTextComponent
+     */
+    mode: DOT_EDITABLE_TEXT_MODE;
+    /**
+     * Represents the format of the editor which can be `text` or `html`
+     *
+     * @type {DOT_EDITABLE_TEXT_FORMAT}
+     * @memberof DotCMSEditableTextComponent
+     */
+    format: DOT_EDITABLE_TEXT_FORMAT;
+    /**
+     * Represents the `contentlet` that can be inline edited
+     *
+     * @type {DotCMSContentlet}
+     * @memberof DotCMSEditableTextComponent
+     */
+    contentlet: T;
+    /**
+     * Represents the field name of the `contentlet` that can be edited
+     *
+     * @memberof DotCMSEditableTextComponent
+     */
+    fieldName: keyof T;
+    /**
+     * Represents the content of the `contentlet` that can be edited
+     *
+     * @protected
+     * @memberof DotCMSEditableTextComponent
+     */
+    protected content: string;
+    /**
+     * Represents the configuration of the editor
+     *
+     * @protected
+     * @type {EditorComponent['init']}
+     * @memberof DotCMSEditableTextComponent
+     */
+    protected init: EditorComponent['init'];
+    /**
+     * The TinyMCE editor
+     *
+     * @readonly
+     * @memberof DotCMSEditableTextComponent
+     */
+    get editor(): DotEditableTextEditor | undefined;
+    /**
+     * Represents if the component is inside the editor
+     *
+     * @protected
+     * @type {boolean}
+     * @memberof DotCMSEditableTextComponent
+     */
+    protected get isEditMode(): string | false | null | undefined;
+    /**
+     * Returns the number of pages the contentlet is on
+     *
+     * @readonly
+     * @memberof DotCMSEditableTextComponent
+     */
+    get onNumberOfPages(): string | 1;
+    /**
+     * Handle copy contentlet inline editing success event
+     *
+     * @param {MessageEvent} { data }
+     * @return {*}
+     * @memberof DotCMSEditableTextComponent
+     */
+    onMessage({ data }: MessageEvent): void;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    /**
+     * Handle mouse down event
+     *
+     * @param {{ event: MouseEvent }} { event }
+     * @return {*}
+     * @memberof DotCMSEditableTextComponent
+     */
+    onMouseDown({ event }: {
+        event: MouseEvent;
+    }): void;
+    /**
+     * Handle focus out event
+     *
+     * @return {*}
+     * @memberof DotCMSEditableTextComponent
+     */
+    onFocusOut(): void;
+    /**
+     * inner HTML to element
+     *
+     * @private
+     * @param {string} editedContent
+     * @return {*}
+     * @memberof DotCMSEditableTextComponent
+     */
+    private innerHTMLToElement;
+    /**
+     * Check if the content has changed
+     *
+     * @private
+     * @param {string} editedContent
+     * @return {*}
+     * @memberof DotCMSEditableTextComponent
+     */
+    private didContentChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DotCMSEditableTextComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DotCMSEditableTextComponent<any>, "dotcms-editable-text", never, { "mode": { "alias": "mode"; "required": false; }; "format": { "alias": "format"; "required": false; }; "contentlet": { "alias": "contentlet"; "required": false; }; "fieldName": { "alias": "fieldName"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a dynamic component entity.
+ * @typedef {Promise<Type<any>>} DynamicComponentEntity
+ * @memberof @dotcms/angular
+ */
+type DynamicComponentEntity = Promise<Type<any>>;
+/**
+ * Represents a DotCMS page component.
+ * Used to store the dynamic components of a DotCMS page.
+ * @typedef {Record<string, DynamicComponentEntity>} DotCMSPageComponent
+ * @memberof @dotcms/angular
+ */
+type DotCMSPageComponent = Record<string, DynamicComponentEntity>;
+
+/**
+ * Represents a Custom Renderer used by the Block Editor Component
+ *
+ * @export
+ * @interface CustomRenderer
+ */
+type CustomRenderer = Record<string, DynamicComponentEntity>;
+/**
+ * A component that renders content from DotCMS's Block Editor field.
+ *
+ * This component provides an easy way to render Block Editor content in your Angular applications.
+ * It handles the rendering of standard blocks and allows customization through custom renderers.
+ *
+ * For more information about Block Editor, see {@link https://dev.dotcms.com/docs/block-editor}
+ *
+ * @example
+ * ```html
+ * <dotcms-block-editor-renderer
+ *   [blocks]="myBlockEditorContent"
+ *   [customRenderers]="myCustomRenderers">
+ * </dotcms-block-editor-renderer>
+ * ```
+ *
+ * @deprecated Use {@link DotCMSBlockEditorRendererNativeComponent}
+ * (`<dotcms-block-editor-renderer-native>`) for accessible, semantic DOM output.
+ * This component wraps every semantic tag in a custom element (e.g. a dispatcher
+ * element sits between `<ul>` and its `<li>` children), which breaks the
+ * `list → listitem` relationship required by the HTML spec and assistive technology.
+ * The native renderer keeps the identical public input API — migration is just
+ * swapping the tag and import. This component is retained for backward compatibility
+ * and will be removed in a future major version.
+ */
+declare class DotCMSBlockEditorRendererComponent {
+    blocks: BlockEditorNode;
+    customRenderers: CustomRenderer | undefined;
+    class: string | undefined;
+    style: string | Record<string, string> | undefined;
+    $blockEditorState: i0.WritableSignal<BlockEditorState>;
+    $isInEditMode: i0.WritableSignal<boolean>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DotCMSBlockEditorRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DotCMSBlockEditorRendererComponent, "dotcms-block-editor-renderer", never, { "blocks": { "alias": "blocks"; "required": false; }; "customRenderers": { "alias": "customRenderers"; "required": false; }; "class": { "alias": "class"; "required": false; }; "style": { "alias": "style"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * An accessible component that renders content from DotCMS's Block Editor field.
+ *
+ * This is the semantic-DOM successor to {@link DotCMSBlockEditorRendererComponent}.
+ * It emits clean semantic HTML — `<ul><li><p>…</p></li></ul>` — with no custom
+ * wrapper elements between semantic tags, so the `list → listitem` relationship
+ * required by the HTML spec and assistive technology is preserved. The recursive
+ * dispatch is performed with `ng-template` outlets, whose host `<ng-container>`s
+ * render as HTML comment nodes (invisible to the accessibility tree).
+ *
+ * It exposes the **identical public input API** and the same `customRenderers`
+ * contract as the deprecated renderer, so migration is just swapping the tag and
+ * import.
+ *
+ * For more information about Block Editor, see {@link https://dev.dotcms.com/docs/block-editor}
+ *
+ * @example
+ * ```html
+ * <dotcms-block-editor-renderer-native
+ *   [blocks]="myBlockEditorContent"
+ *   [customRenderers]="myCustomRenderers">
+ * </dotcms-block-editor-renderer-native>
+ * ```
+ */
+declare class DotCMSBlockEditorRendererNativeComponent implements OnInit {
+    /** The Block Editor `doc` node to render. */
+    readonly blocks: i0.InputSignal<BlockEditorNode | undefined>;
+    /** Map of `node.type` → component to override the built-in render path. */
+    readonly customRenderers: i0.InputSignal<CustomRenderer | undefined>;
+    /**
+     * CSS class on the wrapper element. Aliased as `class` so consumers can
+     * pass `[class]="…"` like a normal Angular class binding.
+     */
+    readonly cssClass: i0.InputSignal<string | undefined>;
+    /** Inline style on the wrapper element. */
+    readonly style: i0.InputSignal<string | Record<string, string> | undefined>;
+    $blockEditorState: i0.WritableSignal<BlockEditorState>;
+    $isInEditMode: i0.WritableSignal<boolean>;
+    protected readonly BLOCKS: typeof BlockEditorDefaultBlocks;
+    ngOnInit(): void;
+    /**
+     * Normalizes a heading `level` attribute (which may be a number such as `6`
+     * or a string such as `'6'`) to a string for use in the heading `@switch`.
+     * Returns `''` for missing or out-of-range levels so the template falls
+     * through to the safe `@default` case (`<h2>`).
+     */
+    asLevel(level: number | string | undefined): string;
+    /** The marks after the current (outermost) one — used to recurse inward. */
+    restMarks(marks: BlockEditorMark[] | undefined): BlockEditorMark[];
+    /** The attributes of the current (outermost) mark. */
+    markAttrs(marks: BlockEditorMark[] | undefined): Record<string, string>;
+    /**
+     * Wrapper style for a `dotImage` `<figure>`, derived from the node's
+     * `textWrap` (float left/right) or `textAlign` attribute.
+     */
+    imageStyle(attrs: BlockEditorNode['attrs']): Record<string, string>;
+    /** Poster URL for a `dotVideo` `<video>` (from `attrs.data.thumbnail`). */
+    videoPoster(attrs: BlockEditorNode['attrs']): string | undefined;
+    /**
+     * The column span (1–12) for a grid column. Falls back to `6` for malformed
+     * `columns` attrs or for an out-of-range column index, matching the legacy
+     * renderer.
+     */
+    columnSpan(attrs: BlockEditorNode['attrs'], index: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DotCMSBlockEditorRendererNativeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DotCMSBlockEditorRendererNativeComponent, "dotcms-block-editor-renderer-native", never, { "blocks": { "alias": "blocks"; "required": false; "isSignal": true; }; "customRenderers": { "alias": "customRenderers"; "required": false; "isSignal": true; }; "cssClass": { "alias": "class"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @description This component is used to render the layout for a DotCMS page.
+ * @param {DotCMSPageAsset} page - The page to render the layout for
+ * @param {DotCMSPageComponent} components - The components to render the layout for
+ * @param {DotCMSPageRendererMode} mode - The mode to render the layout for
+ *
+ * @example
+ * <dotcms-layout-body [page]="page" [components]="components" [mode]="'development'" />
+ *
+ * @export
+ * @implements {OnChanges}
+ * @class DotCMSLayoutBodyComponent
+ */
+declare class DotCMSLayoutBodyComponent implements OnChanges {
+    #private;
+    page: DotCMSPageAsset;
+    components: DotCMSPageComponent;
+    mode: DotCMSPageRendererMode;
+    $isDevMode: i0.Signal<boolean>;
+    $rows: i0.WritableSignal<DotPageAssetLayoutRow[]>;
+    $isEmpty: i0.WritableSignal<boolean>;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DotCMSLayoutBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DotCMSLayoutBodyComponent, "dotcms-layout-body", never, { "page": { "alias": "page"; "required": true; }; "components": { "alias": "components"; "required": true; }; "mode": { "alias": "mode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DotCMSEditablePageService {
+    #private;
+    /**
+     * Listens for changes to an editable page and returns an Observable that emits the updated page data.
+     * This method initializes the UVE (Universal Visual Editor) and sets up subscriptions to track content changes.
+     *
+     * @example
+     * ```ts
+     * // Import the service
+     * import { DotCMSEditablePageService } from '@dotcms/angular';
+     *
+     * // Inject the service
+     * constructor(private editablePageService: DotCMSEditablePageService) {}
+     *
+     * // Get the page data from your API call
+     * const page = await client.page.get('/');
+     *
+     * // Listen for changes
+     * const subscription = this.editablePageService.listen(page).subscribe(updatedPage => {
+     *   if (updatedPage) {
+     *     // Handle updated page data
+     *     console.log('Page updated:', updatedPage);
+     *   }
+     * });
+     *
+     * // When done listening, unsubscribe
+     * subscription.unsubscribe();
+     * ```
+     *
+     * @param response Optional initial page data
+     * @returns Observable that emits the updated page data or undefined
+     */
+    listen<T extends DotCMSExtendedPageResponse>(response?: DotCMSComposedPageResponse<T>): Observable<DotCMSComposedPageResponse<T> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DotCMSEditablePageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DotCMSEditablePageService>;
+}
+
+export { DotCMSBlockEditorRendererComponent, DotCMSBlockEditorRendererNativeComponent, DotCMSClient, DotCMSEditablePageService, DotCMSEditableTextComponent, DotCMSLayoutBodyComponent, DotCMSShowWhenDirective, provideDotCMSClient, provideDotCMSImageLoader };
+export type { DynamicComponentEntity };
+//# sourceMappingURL=dotcms-angular.d.ts.map

package/types/dotcms-angular.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dotcms-angular.d.ts","sources":["../../../../../libs/sdk/angular/src/lib/directives/dotcms-show-when/dotcms-show-when.directive.ts","../../../../../libs/sdk/angular/src/lib/providers/dotcms-image-loader/dotcms-image_loader.ts","../../../../../libs/sdk/angular/src/lib/providers/dotcms-client/dotcms-client.provider.ts","../../../../../libs/sdk/angular/src/lib/components/dotcms-editable-text/utils.ts","../../../../../libs/sdk/angular/src/lib/components/dotcms-editable-text/dotcms-editable-text.component.ts","../../../../../libs/sdk/angular/src/lib/models/index.ts","../../../../../libs/sdk/angular/src/lib/components/dotcms-block-editor-renderer/dotcms-block-editor-renderer.component.ts","../../../../../libs/sdk/angular/src/lib/components/dotcms-block-editor-renderer-semantic/dotcms-block-editor-renderer-native.component.ts","../../../../../libs/sdk/angular/src/lib/components/dotcms-layout-body/dotcms-layout-body.component.ts","../../../../../libs/sdk/angular/src/lib/services/dotcms-editable-page.service.ts"],"mappings":"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","names":["_angular_core"]}

package/dotcms-angular.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dotcms-angular.d.ts","sourceRoot":"","sources":["../../../../libs/sdk/angular/src/dotcms-angular.ts"],"names":[],"mappings":"AAAA;;GAEG;;AAEH,cAAc,cAAc,CAAC"}

package/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@dotcms/angular" />
-export * from './public_api';
-//# sourceMappingURL=dotcms-angular.d.ts.map

package/lib/components/dotcms-block-editor-renderer/blocks/audio.component.d.ts

@@ -1,12 +0,0 @@
-import { BlockEditorNode } from '@dotcms/types';
-import * as i0 from "@angular/core";
-/**
- * Renders a dotCMS audio block as a native `<audio>` element. Mirrors {@link DotVideoBlock}
- * but without poster/width/height, which are not meaningful for audio.
- */
-export declare class DotAudioBlock {
-    attrs: BlockEditorNode['attrs'];
-    static ɵfac: i0.ɵɵFactoryDeclaration<DotAudioBlock, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DotAudioBlock, "dotcms-block-editor-renderer-audio", never, { "attrs": { "alias": "attrs"; "required": false; }; }, {}, never, never, true, never>;
-}
-//# sourceMappingURL=audio.component.d.ts.map

package/lib/components/dotcms-block-editor-renderer/blocks/audio.component.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"audio.component.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/sdk/angular/src/lib/components/dotcms-block-editor-renderer/blocks/audio.component.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;;AAEhD;;;GAGG;AACH,qBAYa,aAAa;IACb,KAAK,EAAG,eAAe,CAAC,OAAO,CAAC,CAAC;yCADjC,aAAa;2CAAb,aAAa;CAEzB"}

package/lib/components/dotcms-block-editor-renderer/blocks/code.component.d.ts

@@ -1,10 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class DotCodeBlock {
-    static ɵfac: i0.ɵɵFactoryDeclaration<DotCodeBlock, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DotCodeBlock, "dotcms-block-editor-renderer-code-block", never, {}, {}, never, ["*"], true, never>;
-}
-export declare class DotBlockQuote {
-    static ɵfac: i0.ɵɵFactoryDeclaration<DotBlockQuote, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DotBlockQuote, "dotcms-block-editor-renderer-block-quote", never, {}, {}, never, ["*"], true, never>;
-}
-//# sourceMappingURL=code.component.d.ts.map

package/lib/components/dotcms-block-editor-renderer/blocks/code.component.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"code.component.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/sdk/angular/src/lib/components/dotcms-block-editor-renderer/blocks/code.component.ts"],"names":[],"mappings":";AAEA,qBAWa,YAAY;yCAAZ,YAAY;2CAAZ,YAAY;CAAG;AAE5B,qBASa,aAAa;yCAAb,aAAa;2CAAb,aAAa;CAAG"}

package/lib/components/dotcms-block-editor-renderer/blocks/dot-contentlet.component.d.ts

@@ -1,34 +0,0 @@
-import { BlockEditorNode } from '@dotcms/types';
-import { DynamicComponentEntity } from '../../../models';
-import { CustomRenderer } from '../dotcms-block-editor-renderer.component';
-import * as i0 from "@angular/core";
-export declare class NoComponentProvided {
-    contentType: string | undefined;
-    protected readonly style: {
-        backgroundColor: string;
-        color: string;
-        padding: string;
-        borderRadius: string;
-        marginBottom: string;
-        marginTop: string;
-        border: string;
-    };
-    static ɵfac: i0.ɵɵFactoryDeclaration<NoComponentProvided, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NoComponentProvided, "dotcms-no-component-provided", never, { "contentType": { "alias": "contentType"; "required": false; }; }, {}, never, never, true, never>;
-}
-/**
- * DotContent component that renders content based on content type
- */
-export declare class DotContentletBlock {
-    customRenderers: CustomRenderer | undefined;
-    node: BlockEditorNode | undefined;
-    contentComponent: DynamicComponentEntity | undefined;
-    protected readonly $data: import("@angular/core").Signal<any>;
-    private readonly DOT_CONTENT_NO_DATA_MESSAGE;
-    private readonly DOT_CONTENT_NO_MATCHING_COMPONENT_MESSAGE;
-    protected get isDevMode(): boolean;
-    ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DotContentletBlock, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DotContentletBlock, "dotcms-block-editor-renderer-contentlet", never, { "customRenderers": { "alias": "customRenderers"; "required": false; }; "node": { "alias": "node"; "required": false; }; }, {}, never, never, true, never>;
-}
-//# sourceMappingURL=dot-contentlet.component.d.ts.map

package/lib/components/dotcms-block-editor-renderer/blocks/dot-contentlet.component.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dot-contentlet.component.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/sdk/angular/src/lib/components/dotcms-block-editor-renderer/blocks/dot-contentlet.component.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAY,MAAM,eAAe,CAAC;AAG1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;;AAE3E,qBAqBa,mBAAmB;IACnB,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,SAAS,CAAC,QAAQ,CAAC,KAAK;;;;;;;;MAQtB;yCAVO,mBAAmB;2CAAnB,mBAAmB;CAW/B;AAED;;GAEG;AACH,qBAYa,kBAAkB;IAClB,eAAe,EAAE,cAAc,GAAG,SAAS,CAAC;IAC5C,IAAI,EAAE,eAAe,GAAG,SAAS,CAAC;IAE3C,gBAAgB,EAAE,sBAAsB,GAAG,SAAS,CAAC;IACrD,SAAS,CAAC,QAAQ,CAAC,KAAK,sCAA8C;IAEtE,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAC0I;IACtL,OAAO,CAAC,QAAQ,CAAC,yCAAyC,CAC0G;IACpK,SAAS,KAAK,SAAS,YAEtB;IAED,QAAQ;yCAfC,kBAAkB;2CAAlB,kBAAkB;CA6B9B"}

package/lib/components/dotcms-block-editor-renderer/blocks/grid-block.component.d.ts

@@ -1,13 +0,0 @@
-import { BlockEditorNode } from '@dotcms/types';
-import { CustomRenderer } from '../dotcms-block-editor-renderer.component';
-import { DotCMSBlockEditorItemComponent } from '../item/dotcms-block-editor-item.component';
-import * as i0 from "@angular/core";
-export declare class DotGridBlock {
-    node: BlockEditorNode | undefined;
-    customRenderers: CustomRenderer | undefined;
-    blockEditorItem: typeof DotCMSBlockEditorItemComponent;
-    get columnSpans(): number[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<DotGridBlock, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DotGridBlock, "dotcms-block-editor-renderer-grid-block", never, { "node": { "alias": "node"; "required": false; }; "customRenderers": { "alias": "customRenderers"; "required": false; }; }, {}, never, never, true, never>;
-}
-//# sourceMappingURL=grid-block.component.d.ts.map

package/lib/components/dotcms-block-editor-renderer/blocks/grid-block.component.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"grid-block.component.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/sdk/angular/src/lib/components/dotcms-block-editor-renderer/blocks/grid-block.component.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,8BAA8B,EAAE,MAAM,4CAA4C,CAAC;;AAE5F,qBAyBa,YAAY;IACZ,IAAI,EAAE,eAAe,GAAG,SAAS,CAAC;IAClC,eAAe,EAAE,cAAc,GAAG,SAAS,CAAC;IAErD,eAAe,wCAAkC;IAEjD,IAAI,WAAW,IAAI,MAAM,EAAE,CAS1B;yCAfQ,YAAY;2CAAZ,YAAY;CAgBxB"}

package/lib/components/dotcms-block-editor-renderer/blocks/image.component.d.ts

@@ -1,25 +0,0 @@
-import { BlockEditorNode } from '@dotcms/types';
-import * as i0 from "@angular/core";
-export declare class DotImageBlock {
-    attrs: BlockEditorNode['attrs'];
-    protected readonly $srcURL: import("@angular/core").Signal<any>;
-    protected readonly $wrapperStyle: import("@angular/core").Signal<{
-        float: string;
-        width: string;
-        margin: string;
-        'text-align'?: undefined;
-    } | {
-        'text-align': any;
-        float?: undefined;
-        width?: undefined;
-        margin?: undefined;
-    } | {
-        float?: undefined;
-        width?: undefined;
-        margin?: undefined;
-        'text-align'?: undefined;
-    }>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DotImageBlock, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DotImageBlock, "dotcms-block-editor-renderer-image", never, { "attrs": { "alias": "attrs"; "required": false; }; }, {}, never, never, true, never>;
-}
-//# sourceMappingURL=image.component.d.ts.map

package/lib/components/dotcms-block-editor-renderer/blocks/image.component.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"image.component.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/sdk/angular/src/lib/components/dotcms-block-editor-renderer/blocks/image.component.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;;AAEhD,qBAUa,aAAa;IACb,KAAK,EAAG,eAAe,CAAC,OAAO,CAAC,CAAC;IAE1C,SAAS,CAAC,QAAQ,CAAC,OAAO,sCAAuC;IAEjE,SAAS,CAAC,QAAQ,CAAC,aAAa;;;;;;;;;;;;;;;OAa7B;yCAlBM,aAAa;2CAAb,aAAa;CAmBzB"}