@cuby-ui/core 0.0.487 → 0.0.489

package/editor/components/editor-video-tool/editor-video-tool.options.d.ts

@@ -0,0 +1,26 @@
+import type { API } from '@editorjs/editorjs';
+import type { CuiFileData } from '../../interfaces/file-response-data';
+import { CuiFileUploaderConfig } from '../../utils/file-uploader';
+export declare const EDITOR_VIDEO_TOOL_SELECTOR = "cc-editor-video-tool";
+export type VideoKeysObject<V = string> = {
+    [key: string]: V;
+};
+export interface CuiVideoToolConfig extends CuiFileUploaderConfig {
+    readonly buttonContent: string;
+}
+export interface CuiVideoToolPlayer {
+    readonly pip: boolean;
+    readonly controls: boolean;
+    readonly light: boolean;
+    readonly playing: boolean;
+}
+export interface CuiVideoToolOptions {
+    readonly api: API;
+    readonly config: CuiVideoToolConfig;
+    readonly onSelectFile: () => void;
+    readonly readOnly: boolean;
+}
+export interface CuiVideoToolData {
+    caption: string;
+    file: CuiFileData;
+}

package/editor/components/editor-video-tool/index.d.ts

@@ -0,0 +1,2 @@
+export { EditorVideoToolComponent } from './editor-video-tool.component';
+export * from './editor-video-tool.options';

package/editor/components/index.d.ts

@@ -0,0 +1,7 @@
+export { EditorToolModalComponent, EDITOR_TOOL_MODAL_SELECTOR, Tool } from './editor-tool-modal';
+export { EditorTooltipComponent, EDITOR_TOOLTIP_SELECTOR, EditorTooltipOptions } from './editor-tooltip';
+export { MarkerModalComponent, MARKER_MODAL_SELECTOR, MarkerData } from './marker-modal';
+export { MarkerSelectComponent, MARKER_SELECT_SELECTOR } from './marker-select';
+export { EditorAttachesToolComponent, EDITOR_ATTACHES_TOOL_SELECTOR, CuiAttachesToolConfig } from './editor-attaches-tool';
+export { EditorImageToolComponent, EDITOR_IMAGE_TOOL_SELECTOR, CuiImageToolConfig } from './editor-image-tool';
+export { EditorVideoToolComponent, EDITOR_VIDEO_TOOL_SELECTOR, CuiVideoToolConfig } from './editor-video-tool';

package/editor/components/marker-modal/index.d.ts

@@ -0,0 +1,3 @@
+export { MarkerModalComponent } from './marker-modal.component';
+export { MarkerData } from './marker-modal.interfaces';
+export { MARKER_MODAL_SELECTOR } from './marker-modal.options';

package/editor/components/marker-modal/marker-modal.component.d.ts

@@ -0,0 +1,62 @@
+import type { OnDestroy, OnInit } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import type { Tool } from '../editor-tool-modal';
+import type { MarkerData, MarkerDataControl } from './marker-modal.interfaces';
+import * as i0 from "@angular/core";
+import * as i1 from "@cuby-ui/cdk";
+export declare class MarkerModalComponent implements OnInit, OnDestroy {
+    private readonly element;
+    private readonly document;
+    private readonly destroyRef;
+    private readonly cuiClickOutsideDirective;
+    private readonly cuiIdService;
+    private readonly markersService;
+    protected readonly TITLE_MAX_LENGTH = 100;
+    protected readonly formTitle: import("@angular/core").WritableSignal<string>;
+    protected readonly isTitleEmpty: import("@angular/core").Signal<boolean>;
+    protected readonly isTitleMoreThanMaxLength: import("@angular/core").Signal<boolean>;
+    protected readonly isTitleInvalid: import("@angular/core").Signal<boolean>;
+    protected readonly titleId: string;
+    protected readonly dataId: string;
+    protected dynamicDataControl: MarkerDataControl;
+    protected spaceBetweenTargetAndList: number;
+    protected startTitle: string;
+    set title(value: string);
+    set url(value: string);
+    set tool(value: Tool);
+    isGlobal: boolean;
+    isTool: boolean;
+    target: HTMLButtonElement;
+    set space(value: number);
+    saveClicked: EventEmitter<MarkerData>;
+    cancelClicked: EventEmitter<any>;
+    protected isVisible: import("@angular/core").WritableSignal<boolean>;
+    protected isHidden: import("@angular/core").WritableSignal<boolean>;
+    protected editor: HTMLElement;
+    protected currentTool?: Tool;
+    protected readonly targetToggleEventListener: () => void;
+    protected get isFormInvalid(): boolean;
+    protected get isDynamicDataErrorShown(): boolean;
+    protected get hide(): boolean;
+    protected get fixed(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected onTitleLabelClick(element: HTMLDivElement): void;
+    protected onSave(): void;
+    protected onScroll(): void;
+    protected onCancel(): void;
+    protected onClearTitle(titleElement: HTMLElement): void;
+    protected onTitleChange(event: KeyboardEvent): void;
+    protected onTitlePaste(event: ClipboardEvent): void;
+    private initTargetElementListener;
+    private initClickOutsideSubscription;
+    private initOnCloseWhenEditorScroll;
+    private destroyEventListeners;
+    private calculateDropdownPosition;
+    private changePositionX;
+    private changePositionY;
+    private changeGlobalPositionX;
+    private changeGlobalPositionY;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkerModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MarkerModalComponent, "ng-component", never, { "title": { "alias": "title"; "required": false; }; "url": { "alias": "url"; "required": false; }; "tool": { "alias": "tool"; "required": false; }; "isGlobal": { "alias": "isGlobal"; "required": false; }; "isTool": { "alias": "isTool"; "required": false; }; "target": { "alias": "target"; "required": false; }; "space": { "alias": "space"; "required": false; }; }, { "saveClicked": "saveClicked"; "cancelClicked": "cancelClicked"; }, never, never, true, [{ directive: typeof i1.CuiClickOutsideDirective; inputs: {}; outputs: {}; }]>;
+}

package/editor/components/marker-modal/marker-modal.interfaces.d.ts

@@ -0,0 +1,7 @@
+import type { FormControl } from '@angular/forms';
+import type { Tool } from '../editor-tool-modal/editor-tool-modal.options';
+export interface MarkerData {
+    readonly title: string;
+    readonly data?: string | Tool;
+}
+export type MarkerDataControl = FormControl<string> | FormControl<Tool | undefined>;

package/editor/components/marker-modal/marker-modal.options.d.ts

@@ -0,0 +1 @@
+export declare const MARKER_MODAL_SELECTOR = "cc-marker-modal";

package/editor/components/marker-select/component/select-item/select-option.component.d.ts

@@ -0,0 +1,7 @@
+import type { Tool } from '../../../editor-tool-modal';
+import * as i0 from "@angular/core";
+export declare class SelectOptionComponent {
+    tool: Tool;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectOptionComponent, "cc-select-option", never, { "tool": { "alias": "tool"; "required": true; }; }, {}, never, never, true, never>;
+}

package/editor/components/marker-select/index.d.ts

@@ -0,0 +1,2 @@
+export { MarkerSelectComponent } from './marker-select.component';
+export { MARKER_SELECT_SELECTOR } from './marker-select.options';

package/editor/components/marker-select/marker-select.component.d.ts

@@ -0,0 +1,40 @@
+import type { OnDestroy, OnInit } from '@angular/core';
+import type { CuiNullable, CuiOnChange, CuiOnTouched } from '@cuby-ui/cdk';
+import type { Tool } from '../editor-tool-modal/editor-tool-modal.options';
+import * as i0 from "@angular/core";
+import * as i1 from "@cuby-ui/cdk";
+export declare class MarkerSelectComponent implements OnInit, OnDestroy {
+    private readonly document;
+    private readonly destroyRef;
+    private readonly cuiClickOutsideDirective;
+    private readonly element;
+    private readonly markersService;
+    private SPACE_BETWEEN_TARGET_AND_LIST;
+    target: HTMLButtonElement;
+    set space(value: number);
+    protected isVisible: import("@angular/core").WritableSignal<boolean>;
+    protected isHidden: import("@angular/core").WritableSignal<boolean>;
+    protected editor: HTMLElement;
+    protected value: CuiNullable<Tool>;
+    protected elements: Tool[];
+    protected onChange: CuiOnChange<unknown>;
+    protected onTouched: CuiOnTouched;
+    protected readonly targetToggleEventListener: () => void;
+    protected get hide(): boolean;
+    writeValue(value: Tool): void;
+    registerOnChange(fn: CuiOnChange<unknown>): void;
+    registerOnTouched(fn: CuiOnTouched): void;
+    protected onScroll(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected onToolClick(tool: Tool): void;
+    private initTargetElementListener;
+    private initClickOutsideSubscription;
+    private initOnCloseWhenEditorScroll;
+    private destroyEventListeners;
+    private calculateDropdownPosition;
+    private changePositionX;
+    private changePositionY;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkerSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MarkerSelectComponent, "cc-marker-select", never, { "target": { "alias": "target"; "required": false; }; "space": { "alias": "space"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.CuiClickOutsideDirective; inputs: {}; outputs: {}; }]>;
+}

package/editor/components/marker-select/marker-select.options.d.ts

@@ -0,0 +1 @@
+export declare const MARKER_SELECT_SELECTOR = "marker-select";

package/editor/config/custom-elements.d.ts

@@ -0,0 +1,2 @@
+import { CuiCustomElement } from '../interfaces';
+export declare const EDITOR_CUSTOM_ELEMENTS: readonly CuiCustomElement[];

package/editor/config/editor.config.d.ts

@@ -0,0 +1,3 @@
+import type { EditorConfig } from '@editorjs/editorjs';
+import type { CuiEditorConfig } from '../interfaces';
+export declare const getEditorConfig: (id: string, config?: CuiEditorConfig) => EditorConfig;

package/editor/config/index.d.ts

@@ -0,0 +1 @@
+export { getEditorConfig } from './editor.config';

package/editor/constants/editor.constants.d.ts

@@ -0,0 +1,15 @@
+import { Translation } from '@jsverse/transloco';
+import type { CuiEditorConfig } from '../interfaces';
+export declare const COMBINED_TEXT_BLOCK_PART = "combined-text-block-part";
+export declare const COMBINED_TEXT_BLOCK = "combined-text-block";
+export declare const COMBINED_TEXT_BLOCK_NAME = "paragraph";
+export declare const COMBINED_TEXT_BLOCK_ADDED = "combinedTextBlockAdded";
+export declare const COMBINED_TEXT_BLOCK_UPDATED = "combinedTextBlockUpdated";
+export declare const COMBINED_TEXT_BLOCK_REMOVED = "combinedTextBlockRemoved";
+export declare const SPLIT_MAX_LENGTH = 1000;
+export declare const SPLIT_LENGTH = 500;
+export declare const EDITOR_SELECTOR = "[data-editor]";
+export declare const DEFAULT_PLACEHOLDER = "Type text or '/' for commands...";
+export declare const DEFAULT_READONLY_PLACEHOLDER = "No 'Description' was provided";
+export declare const DEFAULT_CONFIG: CuiEditorConfig;
+export declare const CuiEditorTranslations: Record<string, Promise<Translation>>;

package/editor/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './editor.constants';

package/editor/editor.component.d.ts

@@ -0,0 +1,74 @@
+import type { ElementRef, OnDestroy } from '@angular/core';
+import EditorJS from '@editorjs/editorjs';
+import type { CuiEditorConfig } from './interfaces';
+import * as i0 from "@angular/core";
+export declare class CuiEditorComponent implements OnDestroy {
+    private readonly destroy;
+    private readonly cuiIdService;
+    private readonly editorService;
+    private readonly jTextService;
+    private readonly POOLING_DELAY;
+    private readonly ELEMENT_SPACE_TO_BOTTOM;
+    private readonly SCROLL_THROTTLE_TIME;
+    private readonly emptyQueue;
+    private poolingSubscription;
+    private scrollSubscription;
+    private isSkipCombinedBlockOnChange;
+    private isFirst;
+    private isChanging;
+    private isSkip;
+    private isRequested;
+    private isDestroyed;
+    private blockIdsMap;
+    private combinedBlocks;
+    private index;
+    private page;
+    private addedBlocks;
+    private updatedBlocks;
+    private removedBlocksIds;
+    private changesQueue;
+    private abortController;
+    protected readonly editorId: string;
+    private readonly isReadonly;
+    protected readonly editorRef: import("@angular/core").Signal<ElementRef<HTMLElement>>;
+    readonly editorApiId: import("@angular/core").InputSignal<string>;
+    readonly config: import("@angular/core").InputSignal<CuiEditorConfig>;
+    readonly requestSize: import("@angular/core").InputSignal<number>;
+    readonly editorEmpty: import("@angular/core").OutputEmitterRef<boolean>;
+    editor: EditorJS;
+    editorElement: HTMLElement;
+    constructor();
+    ngOnDestroy(): void;
+    private onScrollEvent;
+    private onEditorChange;
+    private onAddedCombinedBlock;
+    private onUpdatedCombinedBlock;
+    private onRemovedCombinedBlock;
+    private initEditorEffect;
+    private initEditorChanges;
+    private initEditor;
+    private initScrollObserver;
+    private initEditorEvents;
+    private startPooling;
+    private destroyEditor;
+    private setListenersOnCustomBlockChanges;
+    private startChanges;
+    private startNextChange;
+    private collectAddedBlocksRequest;
+    private collectUpdatedBlocksRequest;
+    private collectRemovedBlocksRequest;
+    private getBlocks;
+    private addBlock;
+    private addCombinedBlock;
+    private insert;
+    private checkFirst;
+    private setCombinedBlock;
+    private setBlockIdsToMap;
+    private updateElementLocalIdWithMainId;
+    private setStartBlock;
+    private setFocus;
+    private checkIsEmpty;
+    private resetData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuiEditorComponent, "cui-editor", never, { "editorApiId": { "alias": "editorApiId"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "requestSize": { "alias": "requestSize"; "required": false; "isSignal": true; }; }, { "editorEmpty": "editorEmpty"; }, never, never, true, never>;
+}

package/editor/events/editor-drag.event.d.ts

@@ -0,0 +1,2 @@
+export declare function setEditorDragEvents(editorElement: HTMLElement, signal: AbortSignal): void;
+export declare function dragstartListener(event: DragEvent): void;

package/editor/events/editor-keyboard.event.d.ts

@@ -0,0 +1,2 @@
+export declare function setEditorKeyboardEvents(editorElement: HTMLElement, signal: AbortSignal): void;
+export declare function keydownListener(event: KeyboardEvent): void;

package/editor/events/editor-modal.event.d.ts

@@ -0,0 +1,3 @@
+export declare function setEditorInfoModalEvents(editorElement: HTMLElement, signal: AbortSignal): void;
+export declare function pointerUpListener(event: MouseEvent): void;
+export declare function onMarkerClick(marker: HTMLElement): void;

package/editor/events/editor-tooltip.event.d.ts

@@ -0,0 +1,2 @@
+export declare function setEditorTooltipEvents(signal: AbortSignal): void;
+export declare function mouseMoveListener(event: MouseEvent): void;

package/editor/events/set-editor-events.d.ts

@@ -0,0 +1 @@
+export declare function setEditorEvents(editorElement: HTMLElement, signal: AbortSignal): void;

package/editor/index.d.ts

@@ -0,0 +1,9 @@
+export * from './interfaces';
+export { CuiEditorComponent } from './editor.component';
+export { CuiFileUploaderStatus, createEditorTools, openFileInBrowser, setLoading } from './utils';
+export { CuiEditorTranslations } from './constants';
+export { CuiAttachesTool, CuiHeaderTool, CuiImageTool, CuiVideoTool, CuiListTool, CuiLinkMarker, CuiToolMarker, CuiRoleMarker } from './tools';
+export type { CuiEditorReadonlyConfig } from './widgets';
+export { CuiVideoToolConfig, CuiAttachesToolConfig, CuiImageToolConfig } from './components';
+export { CuiEditorReadonlyComponent, CuiEditorBlockComponent, CuiEditorModalComponent } from './widgets';
+export * from './providers';

package/editor/interfaces/angular-element.d.ts

@@ -0,0 +1,2 @@
+import type { NgElement, WithProperties } from '@angular/elements';
+export type CuiAngularElement<T> = NgElement & WithProperties<T>;

package/editor/interfaces/blocks-request-data.d.ts

@@ -0,0 +1,6 @@
+import type { Observable } from 'rxjs';
+import type { CuiFullBlockData } from './full-block-data';
+export interface CuiBlocksRequestData {
+    readonly addBlocks$: Observable<string[]>;
+    readonly addedBlocks: CuiFullBlockData[];
+}

package/editor/interfaces/combined-block-adding-event.d.ts

@@ -0,0 +1,7 @@
+import { CuiBlock } from '@cuby-ui/api';
+export interface CuiCombinedBlockAddingEvent {
+    readonly index: number;
+    readonly blockIndex: number;
+    readonly blocks: CuiBlock[];
+    readonly data: CuiBlock[];
+}

package/editor/interfaces/combined-block-data.d.ts

@@ -0,0 +1,5 @@
+import type { CuiCombinedPartBlock } from './combined-part-block-data';
+export interface CuiCombinedBlockToolData {
+    id: string;
+    textBlocks: CuiCombinedPartBlock[];
+}

package/editor/interfaces/combined-part-block-data.d.ts

@@ -0,0 +1,7 @@
+import { CuiBlock } from '@cuby-ui/api';
+export interface CuiCombinedPartBlockData {
+    readonly text: string;
+    readonly parentId: string;
+    readonly parentType: string;
+}
+export type CuiCombinedPartBlock = CuiBlock<CuiCombinedPartBlockData>;

package/editor/interfaces/custom-element.d.ts

@@ -0,0 +1,5 @@
+import type { Type } from '@angular/core';
+export interface CuiCustomElement {
+    readonly selector: string;
+    readonly component: Type<unknown>;
+}

package/editor/interfaces/editor-service.d.ts

@@ -0,0 +1,4 @@
+import { CuiTools } from './tools';
+export interface EditorData {
+    readonly tools: CuiTools;
+}

package/editor/interfaces/event-action-data.d.ts

@@ -0,0 +1,5 @@
+import type { BlockMutationEvent } from '@editorjs/editorjs';
+import type { EventActions } from '../services/editor-service.options';
+export type CuiEventActionData = {
+    [key in EventActions]: BlockMutationEvent[];
+};

package/editor/interfaces/file-response-data.d.ts

@@ -0,0 +1,15 @@
+export interface CuiFileResponseData {
+    readonly id: string;
+    readonly downloadUrl: string;
+}
+export interface CuiResourceFile {
+    readonly id: string;
+    readonly success: number;
+    readonly file: CuiFileData;
+}
+export interface CuiFileData {
+    readonly url: string;
+    readonly size?: number;
+    readonly name?: string;
+    readonly extension?: string;
+}

package/editor/interfaces/full-block-data.d.ts

@@ -0,0 +1,8 @@
+import { CuiBlock } from '@cuby-ui/api';
+export interface CuiFullBlockData extends CuiBlockData {
+    readonly index: number;
+}
+export interface CuiBlockData {
+    readonly id: string;
+    readonly block: CuiBlock;
+}

package/editor/interfaces/index.d.ts

@@ -0,0 +1,15 @@
+export * from './blocks-request-data';
+export * from './combined-block-adding-event';
+export * from './combined-block-data';
+export * from './combined-part-block-data';
+export * from './event-action-data';
+export * from './file-response-data';
+export * from './full-block-data';
+export { CuiEditorConfig } from './main-editor-config';
+export * from './custom-element';
+export * from './angular-element';
+export * from './mutation-actions';
+export * from './parent';
+export * from './tools';
+export * from './tune';
+export * from './editor-service';

package/editor/interfaces/main-editor-config.d.ts

@@ -0,0 +1,12 @@
+import { CuiApiContext } from '@cuby-ui/api';
+import type { CuiTools } from './tools';
+export interface CuiEditorConfig {
+    readonly tools?: CuiTools;
+    readonly readOnly?: boolean;
+    readonly autofocus?: boolean;
+    readonly element?: HTMLElement;
+    readonly withoutPreload?: boolean;
+    readonly placeholder?: string;
+    readonly readonlyPlaceholder?: string;
+    readonly requestOptions?: CuiApiContext;
+}

package/editor/interfaces/mutation-actions.d.ts

@@ -0,0 +1,5 @@
+export type CuiMutationCallback = (mutationList: MutationRecord[]) => void;
+export interface CuiMutationActions {
+    readonly updatedElements: Set<HTMLElement>;
+    readonly removedElementsIds: Set<string>;
+}

package/editor/interfaces/parent.d.ts

@@ -0,0 +1,4 @@
+export interface CuiParent {
+    readonly className: string;
+    readonly parent: Element;
+}

package/editor/interfaces/tools.d.ts

@@ -0,0 +1,4 @@
+import type { ToolConstructable, ToolSettings } from '@editorjs/editorjs';
+export type CuiTools = {
+    [key: string]: ToolConstructable | ToolSettings;
+};

package/editor/interfaces/tune.d.ts

@@ -0,0 +1,6 @@
+export interface CuiTune {
+    readonly name: string;
+    readonly title: string;
+    readonly icon?: string;
+    readonly toggle: boolean;
+}

package/editor/pipes/file-size.pipe.d.ts

@@ -0,0 +1,9 @@
+import type { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FileSizePipe implements PipeTransform {
+    private readonly SIZES;
+    private readonly BYTES_IN_KILOBYTE;
+    transform(bytes: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FileSizePipe, "fileSize", true>;
+}

package/editor/providers/editor.provider.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '@angular/core';
+export declare function cuiProvideEditor(): Provider;

package/editor/providers/index.d.ts

@@ -0,0 +1 @@
+export * from './editor.provider';

package/editor/services/editor-service.options.d.ts

@@ -0,0 +1,8 @@
+export declare const BlockConversionToCombined: {
+    paragraph: string;
+};
+export declare const enum EventActions {
+    add = "block-added",
+    update = "block-changed",
+    remove = "block-removed"
+}

package/editor/services/editor.service.d.ts

@@ -0,0 +1,23 @@
+import type EditorJS from '@editorjs/editorjs';
+import type { BlockMutationEvent, OutputData } from '@editorjs/editorjs';
+import type { Observable } from 'rxjs';
+import { CuiBlock } from '@cuby-ui/api';
+import type { CuiCombinedBlockAddingEvent, CuiCombinedBlockToolData, CuiEventActionData, CuiFullBlockData } from '../interfaces';
+import * as i0 from "@angular/core";
+export declare class CuiEditorService {
+    private readonly destroyRef;
+    private readonly jtextService;
+    sortEventsByTypes(events: BlockMutationEvent[]): CuiEventActionData;
+    collectAddedBlocksRequest(editorId: string, addedBlocks: CuiFullBlockData[]): Observable<string[]>;
+    collectUpdatedBlocksRequest(updatedBlocks: CuiBlock[], blockIdsMap: Map<string, string>): Observable<CuiBlock[]>;
+    collectRemovedBlocksRequest(editorId: string, removedBlocksIds: string[], blockIdsMap: Map<string, string>): Observable<void>;
+    getFullBlockData(event: BlockMutationEvent, editorData: OutputData): CuiFullBlockData;
+    setListenersOnCustomBlockChanges(editor: EditorJS, data: {
+        removedCallback: (blockIds: string[]) => void;
+        updatedCallback: (updatedBlocks: CuiBlock[]) => void;
+        addedCallback: (data: CuiCombinedBlockAddingEvent) => void;
+    }): void;
+    setStartBlock(editorId: string, callback: (block: CuiBlock<CuiCombinedBlockToolData>, id: string) => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiEditorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiEditorService>;
+}

package/editor/services/index.d.ts

@@ -0,0 +1,4 @@
+export * from './editor-service.options';
+export * from './editor.service';
+export * from './markers-service.options';
+export * from './markers.service';

package/editor/services/markers-service.options.d.ts

@@ -0,0 +1,4 @@
+export declare const enum MarkerType {
+    role = "role",
+    tool = "tool"
+}

package/editor/services/markers.service.d.ts

@@ -0,0 +1,11 @@
+import type { Tool } from '../components/editor-tool-modal';
+import { MarkerType } from './markers-service.options';
+import * as i0 from "@angular/core";
+export declare class CuiMarkersService {
+    protected roles: Tool[];
+    protected tools: Tool[];
+    getMarkersByType(type: MarkerType): Tool[];
+    getMarkerObjectByType(type: MarkerType, id: string): Tool | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiMarkersService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CuiMarkersService>;
+}

package/editor/tools/attaches.tool.d.ts

@@ -0,0 +1,31 @@
+import type { API, BlockAPI, ToolboxConfig } from '@editorjs/editorjs';
+import type { CuiFileData } from '../interfaces';
+import type { CuiAttachesToolConfig, CuiAttachesToolData } from '../components/editor-attaches-tool/editor-attaches-tool.options';
+import { CuiFileUploader } from '../utils/file-uploader';
+export declare class CuiAttachesTool {
+    private readonly abortController;
+    private readonly abortSignal;
+    private attachesTool;
+    private selectedFile;
+    api: API;
+    config: CuiAttachesToolConfig;
+    blockApi?: BlockAPI;
+    readOnly: boolean;
+    data: CuiAttachesToolData;
+    uploader: CuiFileUploader;
+    static get isReadOnlySupported(): boolean;
+    static get toolbox(): ToolboxConfig;
+    constructor(options: {
+        api: API;
+    });
+    appendCallback(): void;
+    render(): HTMLElement;
+    save(): CuiAttachesToolData;
+    removed(): void;
+    changeCaption: (event: Event) => void;
+    selectFile: () => void;
+    clickFile: () => void;
+    set file(file: CuiFileData);
+    private onUpload;
+    private uploadingFailed;
+}

package/editor/tools/bold.tool.d.ts

@@ -0,0 +1,11 @@
+import type { InlineTool, InlineToolConstructorOptions, SanitizerConfig } from '@editorjs/editorjs';
+import { CuiSelectionBase } from './selection-base.tool';
+export declare class CuiBoldInlineTool extends CuiSelectionBase implements InlineTool {
+    readonly COMMAND = "bold";
+    static title: string;
+    static get sanitize(): SanitizerConfig;
+    private readonly CSS;
+    constructor(data: InlineToolConstructorOptions);
+    render(): HTMLButtonElement;
+    get shortcut(): string;
+}

package/editor/tools/combined-text-block.tool.d.ts

@@ -0,0 +1,48 @@
+import type { BlockTool } from '@editorjs/editorjs';
+import type { CuiCombinedPartBlock } from '../interfaces';
+export declare class CuiCombinedTextBlockTool implements BlockTool {
+    private readonly TAG;
+    private readonly DEBOUNCE_TIME;
+    private readonly MAX_CHILD_COUNT_FOR_EMPTY;
+    private readonly PLACEHOLDER_ATTRIBUTE_NAME;
+    private mutationConfig;
+    private api;
+    private data;
+    private placeholder;
+    private wrapper?;
+    private observer?;
+    private lastBlockElement?;
+    private readOnly?;
+    private changes;
+    constructor(options: unknown);
+    static get isInline(): boolean;
+    static get isReadOnlySupported(): boolean;
+    static get enableLineBreaks(): boolean;
+    static get toolbox(): {
+        icon: string;
+        title: string;
+    };
+    static get pasteConfig(): object;
+    onPaste(event: CustomEvent): void;
+    render(): HTMLElement;
+    merge(blocksData: CuiCombinedPartBlock[]): void;
+    save(blockContent: HTMLElement): CuiCombinedPartBlock[];
+    removed(): void;
+    private onMutationEvent;
+    private getMutationCallback;
+    private handleMutations;
+    private getBlockPartObject;
+    private getMutationActions;
+    private setCaretToBlocksEnd;
+    private handleUpdatedBlocks;
+    private handleChangesOutsideBlock;
+    private addBlocks;
+    private updateBlocks;
+    private handleRemovedBlocks;
+    private removeBlocks;
+    private update;
+    private createBlock;
+    private convertDefaultDataToCustom;
+    private checkIsEditorEmpty;
+    private getPlaceholder;
+}