import * as i0 from '@angular/core';
import { Type, EventEmitter, OnInit, OnChanges, SimpleChanges, OnDestroy, AfterViewInit, ElementRef, ChangeDetectorRef, AfterContentChecked, ViewContainerRef, ComponentRef, PipeTransform } from '@angular/core';
import { HttpClient, HttpEvent } from '@angular/common/http';
import { Observable, Subject } from 'rxjs';
import * as i31 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { SafeHtml, DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
import * as i8 from '@angular/material/snack-bar';
import { MatSnackBar } from '@angular/material/snack-bar';
import { ClipboardService } from 'ngx-clipboard';
import * as i21 from '@angular/material/dialog';
import { MatDialog } from '@angular/material/dialog';
import * as i1 from '@angular/common';
import * as i2 from '@angular/forms';
import * as i3 from '@ng-select/ng-select';
import * as i4 from '@angular/material/badge';
import * as i5 from '@angular/material/table';
import * as i6 from '@angular/material/expansion';
import * as i7 from '@angular/material/form-field';
import * as i9 from '@angular/material/progress-bar';
import * as i10 from '@angular/material/progress-spinner';
import * as i11 from '@angular/material/tabs';
import * as i12 from '@angular/material/menu';
import * as i13 from '@angular/material/card';
import * as i14 from '@angular/material/select';
import * as i15 from '@angular/material/tooltip';
import * as i16 from '@angular/material/checkbox';
import * as i17 from '@angular/material/chips';
import * as i18 from '@angular/material/list';
import * as i19 from '@angular/material/button';
import * as i20 from '@angular/material/input';
import * as i22 from '@angular/material/paginator';
import * as i23 from '@angular/material/datepicker';
import * as i24 from '@angular/material/grid-list';
import * as i25 from '@angular/material/slide-toggle';
import * as i26 from '@angular/material/tree';
import * as i27 from '@angular/material/core';
import * as i28 from '@angular/material/autocomplete';
import * as i29 from '@angular/material/sidenav';
import * as i30 from '@angular/material/icon';
import * as i32 from '@angular/material/button-toggle';

interface TagItem {
    tag: string;
    displayValue: string;
    isCustom: boolean;
}
interface HtmlBodyTag {
    tagDescription: TagItem;
    innerHtml: string;
    attributes: Object;
    presentOrEdit: boolean;
}
interface BaseApiResponse {
    isSucceeded: boolean;
    message: string;
}

interface PublicFilesUploadResponse {
    succeeded: boolean;
    errorMessage: string;
    fileIds: Array<number>;
    filesUploadedEventId: string;
}
declare class PublicFileUploadService {
    private readonly _httpClient;
    private readonly baseUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    postFiles(files: FileList, applicationId: string | null): Observable<PublicFilesUploadResponse>;
    postFilesInner(formData: FormData, applicationId: string | null, withProgress: true): Observable<HttpEvent<PublicFilesUploadResponse>>;
    postFilesInner(formData: FormData, applicationId: string | null, withProgress?: false): Observable<PublicFilesUploadResponse>;
    postFilesInner(formData: FormData, applicationId: string | null, withProgress: boolean): Observable<PublicFilesUploadResponse> | Observable<HttpEvent<PublicFilesUploadResponse>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PublicFileUploadService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PublicFileUploadService>;
}

interface PrivateFilesCreatedResult {
    succeeded: boolean;
    errorMessage: string;
    setId: string;
    fileIds: Array<string>;
}
declare class PrivateFileUploadService {
    private readonly _httpClient;
    private readonly baseUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    postFiles(files: FileList, applicationId: string | null): Observable<PrivateFilesCreatedResult>;
    postFilesInner(formData: FormData, applicationId: string | null, withProgress: true): Observable<HttpEvent<PrivateFilesCreatedResult>>;
    postFilesInner(formData: FormData, applicationId: string | null, withProgress?: false): Observable<PrivateFilesCreatedResult>;
    postFilesInner(formData: FormData, applicationId: string | null, withProgress: boolean): Observable<PrivateFilesCreatedResult> | Observable<HttpEvent<PrivateFilesCreatedResult>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrivateFileUploadService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PrivateFileUploadService>;
}

interface ImageRestrictions {
    maxWidth: number | undefined;
    maxHeight: number | undefined;
}
interface FileImageTag {
    type: string;
    data: FileImageTagData;
}
interface FileImageTagData {
    src: string;
    fileId: string;
    screenMediaRequest: string;
}
interface IMediaRequest {
    minScreenWidth: number;
    maxScreenWidth: number;
    maxImageHeight?: number;
    maxImageWidth?: number;
}

interface CrocoHtmlOptions {
    /**
     * Формат сслыки для показа изображений из публичных файлов.
     * Содержит переменные: {sizeType} - тип размера, {fileId} - идентификатор изображения.
     */
    publicImageResizedUrlFormat: string;
    /**
     * Формат сслыки для показа изображений из приватный файлов.
     * Содержит переменные: {sizeType} - тип размера, {fileId} - идентификатор изображения.
     */
    privateImageResizedUrlFormat: string;
    globalMediaRequests?: IMediaRequest[];
    /**
     * Компонент для рендера кастомных виджетов
     */
    customWidgetRendererComponent?: Type<any>;
    /**
     * Использовать кнопку для отрисовки кастомных виджетов
     */
    useCustomWidgetsButton: boolean;
    /**
     * Показывать кнопку для запуска настроек
     */
    showSettingsButton: boolean;
    /**
     * Обработчик нажатия на кнопку кастомных виджетов
     * @returns
     */
    customWidgetClickHandler: (editor: VisualEditorComponent) => void;
}
/**
 * Опции для работы с файлами в редакторе разметки
 */
interface CrocoHtmlEditorFileOptions {
    /**
     * Использовать приватные файлы
     */
    usePrivateFiles: boolean;
    /**
     * Свойство которое подставляется в фильтр с файлами
     */
    applicationId: string | null;
}

declare class CrocoHtmlFileOptionsService {
    private readonly localStorageToken;
    private readonly defaultOptions;
    set(data: CrocoHtmlEditorFileOptions): void;
    get(): CrocoHtmlEditorFileOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<CrocoHtmlFileOptionsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CrocoHtmlFileOptionsService>;
}

interface FilePostingStarted {
    filesCount: number;
}
declare class UploadFilesBtnComponent {
    private _publicFileUploadService;
    private _privateFileUploadService;
    private _htmlSettingsService;
    private fileInput;
    extAccepts: string;
    isMultiple: boolean;
    btnText: string;
    hidden: boolean;
    postFilesStarted: EventEmitter<FilePostingStarted>;
    onPublicFilesUploaded: EventEmitter<PublicFilesUploadResponse>;
    onPrivateFilesUploaded: EventEmitter<PrivateFilesCreatedResult>;
    constructor(_publicFileUploadService: PublicFileUploadService, _privateFileUploadService: PrivateFileUploadService, _htmlSettingsService: CrocoHtmlFileOptionsService);
    handleFileInput(files: FileList): void;
    clickFileInput(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UploadFilesBtnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UploadFilesBtnComponent, "croco-app-upload-files-btn", never, { "extAccepts": { "alias": "extAccepts"; "required": false; }; "isMultiple": { "alias": "isMultiple"; "required": false; }; "btnText": { "alias": "btnText"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; }, { "postFilesStarted": "postFilesStarted"; "onPublicFilesUploaded": "onPublicFilesUploaded"; "onPrivateFilesUploaded": "onPrivateFilesUploaded"; }, never, never, true, never>;
}

declare class AddFilesBtnComponent {
    postFilesStarted: EventEmitter<FilePostingStarted>;
    fakeBtn: UploadFilesBtnComponent;
    fileIds: number[];
    constructor();
    filesTagsReady: EventEmitter<HtmlBodyTag[]>;
    postFilesStartedEventHandler(data: FilePostingStarted): void;
    filesUploadedPublicHandler(data: PublicFilesUploadResponse): void;
    filesUploadedPrivateHandler(data: PrivateFilesCreatedResult): void;
    private buildFileTags;
    handleClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddFilesBtnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AddFilesBtnComponent, "croco-html-add-files-btn", never, {}, { "postFilesStarted": "postFilesStarted"; "filesTagsReady": "filesTagsReady"; }, never, never, true, never>;
}

interface InterfaceBlock {
    type: string;
    data: any;
    validationResult?: BaseApiResponse | undefined;
    bootstrapHtml?: string | undefined;
}

interface TableHeaderData {
    type: "table-header";
    columns: string[];
}
interface TableRowColumnData {
    type: "table-row-column-data";
    data: {
        text: string;
        children: InterfaceBlock[];
    };
}
interface TableRowData {
    type: "table-row-column";
    columns: TableRowColumnData[];
}
interface TableData {
    header: TableHeaderData;
    rows: TableRowData[];
}
interface TableTagData {
    type: "table";
    data: TableData;
}
declare class TableTypes {
    static readonly TableRowColumnData = "table-row-column-data";
    static readonly Table = "table";
    static readonly TableRowColumn = "table-row-column";
}
interface AngularMaterialTableData {
    displayedColumns: string[];
    data: object[];
}
declare class TableMethods {
    static getTableFromHtmlTag(tableTag: HTMLTableElement, options: CrocoHtmlOptions): {
        type: string;
        data: TableData;
        validationResult: BaseApiResponse;
        bootstrapHtml: string;
    } | {
        angularMaterialTableDataCheck: BaseApiResponse;
        type: string;
        data: TableData;
        validationResult: BaseApiResponse;
        bootstrapHtml: string;
    } | {
        angularMaterialTableDataCheck: BaseApiResponse;
        html: string;
        angularMaterialTableData: AngularMaterialTableData;
        type: string;
        data: TableData;
        validationResult: BaseApiResponse;
        bootstrapHtml: string;
    };
    static checkTable(tableData: TableData): BaseApiResponse;
    static getHeader(tableTag: HTMLTableElement): TableHeaderData;
    static getTableRows(tableTag: HTMLTableElement, options: CrocoHtmlOptions): Array<TableRowData>;
}

declare class AngularMaterialTableMethods {
    static getAngularMaterialTableData(columns: string[], rows: TableRowData[]): AngularMaterialTableData;
    static checkHeaders(tableData: TableData): BaseApiResponse;
    static checkAngularMaterialTableData(tableData: TableData, checkHeaders?: boolean): BaseApiResponse;
}

declare class BodyTagsExtensions {
    static getDescription(tagName: string): string;
    static toHtml(bodyTags: HtmlBodyTag[]): string;
    static imageTagToHtml(imageTag: HtmlBodyTag): string;
    static getBodyTags(html: string, options: CrocoHtmlOptions): HtmlBodyTag[];
    static sanitizeInnerHtml(html: string): string;
    static toBodyTag(data: InterfaceBlock): HtmlBodyTag;
}

declare class BootstrapTableMethods {
    static BuildTable(data: TableData): string;
    static BuildHeader(data: TableHeaderData): string;
    static BuildBody(rows: TableRowData[]): string;
    static BuildInnerTags(tags: InterfaceBlock[]): string;
    static BuildInnerTag(data: InterfaceBlock): string;
}

declare class FileImageTagDataConsts {
    static TagName: string;
    static FileIdAttrName: string;
    static ScreenMediaRequest: string;
    static MaxScreenWidth: string;
    static MinScreenWidth: string;
    static MaxImageHeight: string;
    static MaxImageWidth: string;
    static DefaultValueForFileImage: string;
}
declare class ImageMethods {
    static buildUrl(fileId: string, sizeType: string, options: CrocoHtmlOptions): string;
    static buildSmallUrl(fileId: string, options: CrocoHtmlOptions): string;
    static buildMediumUrl(fileId: string, options: CrocoHtmlOptions): string;
    static isPrivateFileId(fileId: string): boolean;
    static ExtractImage(elem: HTMLElement, options: CrocoHtmlOptions): FileImageTag;
    static mediaRequestStringToArrayParser: (data: string) => IMediaRequest[];
    static createMediaRequestValue(arr: string[], attribute: string): number | null;
    static mediaRequestsArrayToString(data: IMediaRequest[]): string;
    static mediaRequestToString(data: IMediaRequest): string;
    static getImageRestrictionsByScreenSize(screenSize: number, requests: IMediaRequest[]): ImageRestrictions;
}

declare class CustomWidgetTagDataConsts {
    static TagName: string;
    static TypeAttrName: string;
    static DataIdAttrName: string;
    static WidgetIdAttrName: string;
}
interface CustomWidgetTag {
    type: string;
    data: CustomWidgetTagData;
}
interface CustomWidgetTagData {
    type: string;
    dataId: string;
    widgetId: string;
}
declare class CustomWidgetMethods {
    static ExtractCustomWidgetTagData(attributes: any): CustomWidgetTagData;
    static ExtractCustomWidgetAttributes(customWidgetTagData: CustomWidgetTagData): any;
    static ExtractCustomWidgetTag(elem: HTMLElement): CustomWidgetTag;
}

declare class TableBuilder {
    static getTableMarkUp(rows: number, cols: number, generateHeaders: boolean): string;
    static getTableHeaderMarkUp(cols: number): string;
    static getTableBodyMarkUp(cols: number, rows: number): string;
}

interface TextBlock {
    type: "text-block" | "text-sup-block" | "text-sub-block";
    data: {
        text: string;
    };
}
interface LineBreakBlock {
    type: "line-break";
}
interface RichTextData {
    type: "rich-text";
    data: {
        children: Array<TextBlock | LineBreakBlock>;
    };
}
declare class TextTags {
    static readonly text = "text";
    static readonly h1 = "h1";
    static readonly h2 = "h2";
    static readonly h3 = "h3";
    static readonly h4 = "h4";
    static readonly h5 = "h5";
    static readonly h6 = "h6";
    static headerTextTags: string[];
    static allTextTags: string[];
}
declare class TextMethods {
    static ExtractRichTextData(elem: HTMLElement): RichTextData;
}

declare class TextTagDataConsts {
    static HAlign: string;
}
declare const TextTag = "text";
interface SimpleTextTag {
    type: "text";
    data: SimpleTextTagData;
}
interface GenericTextTag {
    type: string;
    data: SimpleTextTagData;
}
interface SimpleTextTagData {
    textTagName: string;
    text: string;
    html: string;
    horizontalAlignment: "left" | "right" | "center";
    validationResult: BaseApiResponse;
}
declare class TextSimpleMethods {
    static supportedTags: string[];
    static ExtractTextTag(elem: HTMLElement): SimpleTextTag;
    static ValidateTextHtml(html: string): BaseApiResponse;
    static ValidateTag(element: Element): BaseApiResponse;
}

declare class ExternalVideoTagDataConsts {
    static TagName: string;
    static VideoTypeAttrName: string;
    static LinkAttrName: string;
    static UseResponsiveWrapperAttrName: string;
    static IframeAttrName: string;
}
declare class ExternalVideoSupportedTypes {
    static Youtube: string;
    static VkVideo: string;
    static Code: string;
}
declare const ExternalVideoPlayers: {
    type: string;
    displayValue: string;
}[];
interface ExternalVideoTag {
    type: string;
    data: ExternalVideoTagData;
}
interface ExternalVideoTagData {
    type: string;
    link: string;
    innerHtml: string;
    useResponsiveWrapper: boolean;
}
declare class VideoMethods {
    static ExtractExternalVideoTag(elem: HTMLElement): ExternalVideoTag;
}

declare class XmlExtensions {
    static formatXml(xml: string, tab?: string): string;
    static tagsToLower(xml: string): string;
    static replaceTagToLower(xml: string, tag: string): string;
}

declare class ExternalVideoEditorComponent implements OnInit {
    tag: HtmlBodyTag;
    onTagUpdated: EventEmitter<HtmlBodyTag>;
    protected readonly ExternalVideoSupportedTypes: typeof ExternalVideoSupportedTypes;
    tagData: ExternalVideoTagData;
    linkText: string;
    ngOnInit(): void;
    linkChanged(): void;
    onCheck(checked: boolean): void;
    createLinkByIFrame(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExternalVideoEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExternalVideoEditorComponent, "croco-html-external-video-editor", never, { "tag": { "alias": "tag"; "required": false; }; }, { "onTagUpdated": "onTagUpdated"; }, never, never, true, never>;
}

declare class HtmlRawEditorComponent implements OnChanges {
    private readonly _sanitizer;
    tag: HtmlBodyTag;
    onTagUpdated: EventEmitter<HtmlBodyTag>;
    safeHtml: SafeHtml;
    constructor(_sanitizer: DomSanitizer);
    ngOnChanges(changes: SimpleChanges): void;
    onSafeHtmlChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlRawEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HtmlRawEditorComponent, "croco-html-html-raw-editor", never, { "tag": { "alias": "tag"; "required": false; }; }, { "onTagUpdated": "onTagUpdated"; }, never, never, true, never>;
}

declare class ScreenWidthService {
    private screenWidth;
    constructor();
    private onResize;
    getScreenWidth(): Observable<number>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenWidthService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenWidthService>;
}

declare class ImageEditorComponent implements OnInit, OnDestroy {
    private readonly _options;
    private readonly screenWidthService;
    hasImageError: boolean;
    searchOrEdit: string;
    requests: IMediaRequest[];
    imageMaxHeight: number;
    imageMaxWidth: number;
    isShowMediaRequest: boolean;
    private unsubscribe;
    tag: HtmlBodyTag;
    onErrorHandler(): void;
    onTagUpdated: EventEmitter<HtmlBodyTag>;
    get fileId(): string;
    set fileId(value: string);
    constructor(_options: CrocoHtmlOptions, screenWidthService: ScreenWidthService);
    getSrc(): string;
    hasFileId(): boolean;
    onFileIdChanged(fileId: string): void;
    removeImageError(): void;
    ngOnInit(): void;
    requestChanged(): void;
    addNewMediaRequest(): void;
    deleteMediaRequest(index: number): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImageEditorComponent, "croco-html-image-editor", never, { "tag": { "alias": "tag"; "required": false; }; }, { "onTagUpdated": "onTagUpdated"; }, never, never, true, never>;
}

declare enum EAlignments {
    Left = "left",
    Center = "center",
    Right = "right"
}

declare class HtmlRawTagDataConsts {
    static TagName: string;
}

type SpriteIdsType = 'align-center' | 'align-left' | 'align-right' | 'move-icon' | 'source-code-tab' | 'tag-button-button' | 'tag-button-custom-widget' | 'tag-button-download-file-button' | 'tag-button-external-video' | 'tag-button-file-image' | 'tag-button-html-raw' | 'tag-button-text' | 'viewer-tab' | 'visual-editor-tab';

declare const defaultLinkYouTube = "https://www.youtube.com/embed/4CtSAnJDfsI?si=scyBNJa0Hs2t5aLE";
declare const defaultLinkVk = "https://vk.com/video_ext.php?oid=-22822305&id=456241864&hd=2";
declare const defaultLinkForDownload = "https://storage.yandexcloud.net/mega-academy/presentation.pdf";
declare class VisualEditorComponent implements OnInit, AfterViewInit {
    private readonly _cdref;
    private readonly _options;
    textArea: ElementRef;
    isLoading: boolean;
    loadingText: string;
    text: string;
    htmlRaw: string;
    alignment: EAlignments;
    textTag: string;
    textTagOptions: TagItem[];
    alignmentOptions: {
        value: EAlignments;
        text: string;
    }[];
    showMarkUp: boolean;
    tags: TagItem[];
    videoPlayers: {
        type: string;
        displayValue: string;
    }[];
    selectedValue: string;
    selectedVideoPlayer: string;
    protected readonly ExternalVideoTagDataConsts: typeof ExternalVideoTagDataConsts;
    protected readonly HtmlRawTagDataConsts: typeof HtmlRawTagDataConsts;
    protected readonly ExternalVideoSupportedTypes: typeof ExternalVideoSupportedTypes;
    useHtmlRaw: boolean;
    html: string;
    isHtmlSet(): boolean;
    clearHtml(): void;
    getHtml(): string;
    onHtmlChanged: EventEmitter<string>;
    rendered: EventEmitter<boolean>;
    bodyTags: HtmlBodyTag[];
    saveBodyTags: HtmlBodyTag[];
    useCustomWidgetsButton: boolean;
    constructor(_cdref: ChangeDetectorRef, _options: CrocoHtmlOptions);
    ngAfterViewInit(): void;
    ngAfterContentChecked(): void;
    addTagClickHandler(): void;
    startAddingText(tag?: string): void;
    resetTextStyle(): void;
    addTextTags(): void;
    postFilesStartedEventHandler(): void;
    addTag(tag: HtmlBodyTag): void;
    filesTagsReadyHandler(tags: HtmlBodyTag[]): void;
    drop(event: CdkDragDrop<object[]>): void;
    onTagSavedHandler(tag: HtmlBodyTag): void;
    onTagRemovedHandler(index: number): void;
    recalculateHtml(): void;
    recalculateBodyTags(): void;
    selectTag(data: TagItem): void;
    customWidgetsClickHandler(): void;
    ngOnInit(): void;
    setTagButton(type: string): SpriteIdsType;
    setAlignButton(type: string): SpriteIdsType;
    static ɵfac: i0.ɵɵFactoryDeclaration<VisualEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VisualEditorComponent, "croco-visual-editor", never, { "showMarkUp": { "alias": "showMarkUp"; "required": false; }; "useHtmlRaw": { "alias": "useHtmlRaw"; "required": false; }; "html": { "alias": "html"; "required": false; }; }, { "html": "html"; "onHtmlChanged": "onHtmlChanged"; "rendered": "rendered"; }, never, never, true, never>;
}

declare class MainEditorComponent implements OnInit, AfterContentChecked, AfterViewInit {
    private readonly _clipboardService;
    private readonly _snackBar;
    private readonly _cdref;
    private readonly _dialog;
    private readonly _htmlSettingsService;
    visualEditorRendered: boolean;
    visualEditor: VisualEditorComponent;
    showMarkUp: boolean;
    useHtmlRaw: boolean;
    html: string;
    onHtmlChanged: EventEmitter<string>;
    showSettingsButton: boolean;
    constructor(_clipboardService: ClipboardService, _snackBar: MatSnackBar, _cdref: ChangeDetectorRef, _dialog: MatDialog, _htmlSettingsService: CrocoHtmlFileOptionsService, options: CrocoHtmlOptions);
    ngAfterViewInit(): void;
    ngAfterContentChecked(): void;
    visualEditorRenderedHandler(): void;
    onHtmlChangedHandler(html: string): void;
    textAreaModelChangedHandler(): void;
    recalculateBodyTags(): void;
    copyMarkUp(): void;
    ngOnInit(): void;
    openSettingsModal(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MainEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MainEditorComponent, "croco-html-main-editor", never, { "showMarkUp": { "alias": "showMarkUp"; "required": false; }; "useHtmlRaw": { "alias": "useHtmlRaw"; "required": false; }; "html": { "alias": "html"; "required": false; }; }, { "html": "html"; "onHtmlChanged": "onHtmlChanged"; }, never, never, true, never>;
}

declare class MainEditorBlockComponent {
    textTags: string[];
    tag: HtmlBodyTag;
    onTagSaved: EventEmitter<HtmlBodyTag>;
    onTagRemoved: EventEmitter<HtmlBodyTag>;
    tagUpdatedHandler(tag: HtmlBodyTag): void;
    save(): void;
    deleteItem(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MainEditorBlockComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MainEditorBlockComponent, "croco-html-main-editor-block", never, { "tag": { "alias": "tag"; "required": false; }; }, { "onTagSaved": "onTagSaved"; "onTagRemoved": "onTagRemoved"; }, never, never, true, never>;
}

declare class TextEditorComponent implements OnInit {
    tag: HtmlBodyTag;
    onTagUpdated: EventEmitter<HtmlBodyTag>;
    constructor();
    ngOnInit(): void;
    getInnerHtml(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextEditorComponent, "croco-html-text-editor", never, { "tag": { "alias": "tag"; "required": false; }; }, { "onTagUpdated": "onTagUpdated"; }, never, never, true, never>;
}

declare class CustomWidgetEditorComponent implements OnInit {
    tag: HtmlBodyTag;
    onTagUpdated: EventEmitter<HtmlBodyTag>;
    tagData: CustomWidgetTagData;
    ngOnInit(): void;
    dataChanged(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomWidgetEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CustomWidgetEditorComponent, "croco-html-custom-widget-editor", never, { "tag": { "alias": "tag"; "required": false; }; }, { "onTagUpdated": "onTagUpdated"; }, never, never, true, never>;
}

interface GetListResult<T> {
    totalCount: number;
    list: Array<T>;
}
interface FileRelationModel {
    entityTypeFullName: string;
    entityKey: string;
    relationName: string;
    relationValue: string;
    relationCustomData: string;
}
interface SearchFilesRequest {
    q: string;
    fileName: string;
    applicationId: string;
    fileTypes: Array<FileType>;
    count: number | null;
    offSet: number;
}
declare enum FileType {
    Undefined = "Undefined",
    Unknown = "Unknown",
    Image = "Image",
    Audio = "Audio",
    Video = "Video",
    Document = "Document",
    Archive = "Archive"
}
interface GetListSearchModel {
    count: number | null;
    offSet: number;
}
interface FileSimpleModel {
    fileId: number;
    fileName: string;
    type: FileType;
    downloadUrl: string;
}

declare class PublicFilesQueryService {
    private readonly _httpClient;
    private readonly _baseControllerUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    search(model: SearchFilesRequest): Observable<GetListResult<FileSimpleModel>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PublicFilesQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PublicFilesQueryService>;
}

interface PrivateFileNameModel {
    id: string;
    setId: string;
    fileName: string;
    type: FileType;
    downloadUrl: string;
    createdOn: string;
    applicationId: string;
}
declare class PrivateFilesQueryService {
    private readonly _httpClient;
    private readonly _baseControllerUrl;
    constructor(_httpClient: HttpClient, baseUrl: string);
    search(model: SearchFilesRequest): Observable<GetListResult<PrivateFileNameModel>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrivateFilesQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PrivateFilesQueryService>;
}

interface SearchQuestionsFormData {
    q: string;
}
interface FileUnifiedModel {
    fileId: string;
    fileName: string;
}
declare class FileIdSelectComponent implements OnInit, OnChanges {
    private readonly _publicFileService;
    private readonly _privateFileService;
    private _htmlSettingsService;
    private readonly _options;
    q: string;
    labelText: string;
    fileId: string;
    loading: boolean;
    files: FileUnifiedModel[];
    onFileIdChanged: EventEmitter<string>;
    get crocoHtmlEditorFileOptions(): CrocoHtmlEditorFileOptions;
    constructor(_publicFileService: PublicFilesQueryService, _privateFileService: PrivateFilesQueryService, _htmlSettingsService: CrocoHtmlFileOptionsService, _options: CrocoHtmlOptions);
    onModelChanged(fileId: string): void;
    getSrc(fileId: string): string;
    ngOnInit(): void;
    loadFiles(): void;
    onSearchChanged(q: {
        term: string;
        items: object[];
    }): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileIdSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileIdSelectComponent, "croco-html-file-id-select", never, { "labelText": { "alias": "labelText"; "required": false; }; "fileId": { "alias": "fileId"; "required": false; }; }, { "fileId": "fileId"; "onFileIdChanged": "onFileIdChanged"; }, never, never, true, never>;
}

declare class XmlTagExternalVideoComponent {
    set data(value: InterfaceBlock);
    set tagData(value: ExternalVideoTagData);
    protected readonly ExternalVideoSupportedTypes: typeof ExternalVideoSupportedTypes;
    _block: ExternalVideoTagData;
    static ɵfac: i0.ɵɵFactoryDeclaration<XmlTagExternalVideoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XmlTagExternalVideoComponent, "croco-html-xml-tag-external-video", never, { "data": { "alias": "data"; "required": false; }; "tagData": { "alias": "tagData"; "required": false; }; }, {}, never, never, true, never>;
}

declare class XmlTagHeaderInnerTextViewComponent implements OnInit {
    item: GenericTextTag;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<XmlTagHeaderInnerTextViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XmlTagHeaderInnerTextViewComponent, "croco-html-xml-tag-header-inner-text-view", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
}

declare class XmlTagHeaderTextViewComponent implements OnInit {
    item: GenericTextTag;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<XmlTagHeaderTextViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XmlTagHeaderTextViewComponent, "croco-html-xml-tag-header-text-view", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
}

declare class XmlTagHtmlViewComponent {
    constructor();
    html: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<XmlTagHtmlViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XmlTagHtmlViewComponent, "croco-html-xml-tag-html-view", never, { "html": { "alias": "html"; "required": false; }; }, {}, never, never, true, never>;
}

declare class XmlTagRichTextViewComponent implements OnInit {
    richTextData: RichTextData;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<XmlTagRichTextViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XmlTagRichTextViewComponent, "croco-html-xml-tag-rich-text-view", never, { "richTextData": { "alias": "richTextData"; "required": false; }; }, {}, never, never, true, never>;
}

declare class XmlTagTableViewComponent {
    displayedColumns: string[];
    data: object;
    static ɵfac: i0.ɵɵFactoryDeclaration<XmlTagTableViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XmlTagTableViewComponent, "croco-html-xml-tag-table-view", never, { "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
}

declare class XmlTagTextViewComponent implements OnInit {
    item: SimpleTextTag;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<XmlTagTextViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XmlTagTextViewComponent, "croco-html-xml-tag-text-view", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
}

declare class XmlTagViewComponent {
    data: InterfaceBlock[];
    isHeaderTextTag(item: InterfaceBlock): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<XmlTagViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XmlTagViewComponent, "croco-html-xml-tag-view", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
}

declare class HtmlRawViewComponent implements OnChanges {
    private readonly _sanitizer;
    rawHtml: string;
    safeHtml: SafeHtml;
    constructor(_sanitizer: DomSanitizer);
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlRawViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HtmlRawViewComponent, "croco-html-raw-view", never, { "rawHtml": { "alias": "rawHtml"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FileImageTagViewComponent implements OnInit, OnDestroy {
    private readonly screenWidthService;
    private readonly _options;
    set item(item: InterfaceBlock);
    imageSrc: string;
    requests: IMediaRequest[];
    private unsubscribe;
    imageMaxHeight: number;
    imageMaxWidth: number;
    constructor(screenWidthService: ScreenWidthService, _options: CrocoHtmlOptions);
    getMediaRequests(screenMediaRequest: string): IMediaRequest[];
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileImageTagViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileImageTagViewComponent, "croco-html-file-image-tag-view", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
}

declare class XmlTagCustomWidgetComponent implements OnInit, OnDestroy {
    private readonly _options;
    viewContainerRef: ViewContainerRef;
    set tagData(value: CustomWidgetTagData);
    get tagData(): CustomWidgetTagData;
    _tagData: CustomWidgetTagData;
    tooltipData: string;
    useDynamicComponent: boolean;
    dynamicContainerRef: ComponentRef<any>;
    constructor(_options: CrocoHtmlOptions);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<XmlTagCustomWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XmlTagCustomWidgetComponent, "croco-html-xml-tag-custom-widget", never, { "tagData": { "alias": "tagData"; "required": false; }; }, {}, never, never, true, never>;
}

declare class HtmlViewComponent {
    html: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HtmlViewComponent, "croco-html-view", never, { "html": { "alias": "html"; "required": false; }; }, {}, never, never, true, never>;
}

declare class RichTextToHtmlPipe implements PipeTransform {
    transform(value: RichTextData): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<RichTextToHtmlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RichTextToHtmlPipe, "richTextToHtml", true>;
}

declare class TagToSpanPipe implements PipeTransform {
    transform(value: string[]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TagToSpanPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TagToSpanPipe, "tagToSpan", true>;
}

declare class ToPreviewPipe implements PipeTransform {
    private readonly _options;
    constructor(_options: CrocoHtmlOptions);
    transform(value: string): InterfaceBlock[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ToPreviewPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ToPreviewPipe, "topreview", true>;
}

declare class ToHtmlBodyTagsPipe implements PipeTransform {
    private readonly _options;
    constructor(_options: CrocoHtmlOptions);
    transform(value: string): HtmlBodyTag[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ToHtmlBodyTagsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ToHtmlBodyTagsPipe, "tohtmlbodytags", true>;
}

declare class ToPreviewHtmlPipe implements PipeTransform {
    private readonly _options;
    constructor(_options: CrocoHtmlOptions);
    transform(value: string): InterfaceBlock[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ToPreviewHtmlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ToPreviewHtmlPipe, "topreviewhtml", true>;
}

declare class ErrorBannerComponent {
    message: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorBannerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorBannerComponent, "croco-html-error-banner", never, { "message": { "alias": "message"; "required": true; }; }, {}, never, never, true, never>;
}

declare class VkVideoPlayerComponent {
    private sanitizer;
    set link(link: string);
    safeUrl: SafeResourceUrl;
    constructor(sanitizer: DomSanitizer);
    static ɵfac: i0.ɵɵFactoryDeclaration<VkVideoPlayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VkVideoPlayerComponent, "vk-video-player", never, { "link": { "alias": "link"; "required": false; }; }, {}, never, never, true, never>;
}

declare class YoutubeVideoPlayerComponent {
    private sanitizer;
    set link(link: string);
    safeUrl: SafeResourceUrl;
    constructor(sanitizer: DomSanitizer);
    static ɵfac: i0.ɵɵFactoryDeclaration<YoutubeVideoPlayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<YoutubeVideoPlayerComponent, "youtube-video-player", never, { "link": { "alias": "link"; "required": false; }; }, {}, never, never, true, never>;
}

interface DownloadButtonTagData {
    title: string;
    link: string;
}

declare class DownloadFileButtonEditorComponent {
    tag: HtmlBodyTag;
    onTagUpdated: EventEmitter<HtmlBodyTag>;
    tagData: DownloadButtonTagData;
    ngOnInit(): void;
    linkChanged(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DownloadFileButtonEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DownloadFileButtonEditorComponent, "croco-html-download-file-button-editor", never, { "tag": { "alias": "tag"; "required": false; }; }, { "onTagUpdated": "onTagUpdated"; }, never, never, true, never>;
}

declare class BlobCreateService {
    private readonly _http;
    constructor(_http: HttpClient);
    getBlob(link: string): Observable<Blob>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BlobCreateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BlobCreateService>;
}

declare class XmlTagDownloadFileButtonComponent {
    private readonly _blobCreateService;
    set data(value: InterfaceBlock);
    set tagData(value: DownloadButtonTagData);
    constructor(_blobCreateService: BlobCreateService);
    _block: DownloadButtonTagData;
    downloadFile(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<XmlTagDownloadFileButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XmlTagDownloadFileButtonComponent, "croco-html-xml-tag-download-file-button", never, { "data": { "alias": "data"; "required": false; }; "tagData": { "alias": "tagData"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CrocoHtmlModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CrocoHtmlModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CrocoHtmlModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i2.ReactiveFormsModule, typeof i3.NgSelectModule, typeof i4.MatBadgeModule, typeof i5.MatTableModule, typeof i6.MatExpansionModule, typeof i7.MatFormFieldModule, typeof i8.MatSnackBarModule, typeof i9.MatProgressBarModule, typeof i10.MatProgressSpinnerModule, typeof i11.MatTabsModule, typeof i12.MatMenuModule, typeof i13.MatCardModule, typeof i14.MatSelectModule, typeof i15.MatTooltipModule, typeof i16.MatCheckboxModule, typeof i17.MatChipsModule, typeof i18.MatListModule, typeof i19.MatButtonModule, typeof i20.MatInputModule, typeof i21.MatDialogModule, typeof i22.MatPaginatorModule, typeof i23.MatDatepickerModule, typeof i24.MatGridListModule, typeof i25.MatSlideToggleModule, typeof i26.MatTreeModule, typeof i27.MatNativeDateModule, typeof i28.MatAutocompleteModule, typeof i29.MatSidenavModule, typeof i30.MatIconModule, typeof i31.DragDropModule, typeof i32.MatButtonToggleModule, typeof ErrorBannerComponent, typeof VkVideoPlayerComponent, typeof YoutubeVideoPlayerComponent, typeof DownloadFileButtonEditorComponent, typeof XmlTagDownloadFileButtonComponent, typeof UploadFilesBtnComponent, typeof HtmlViewComponent, typeof XmlTagTableViewComponent, typeof XmlTagViewComponent, typeof XmlTagRichTextViewComponent, typeof XmlTagHtmlViewComponent, typeof XmlTagTextViewComponent, typeof XmlTagHeaderTextViewComponent, typeof XmlTagHeaderInnerTextViewComponent, typeof XmlTagExternalVideoComponent, typeof HtmlRawViewComponent, typeof FileImageTagViewComponent, typeof XmlTagCustomWidgetComponent, typeof HtmlViewComponent, typeof MainEditorComponent, typeof FileIdSelectComponent, typeof TextEditorComponent, typeof ImageEditorComponent, typeof MainEditorBlockComponent, typeof VisualEditorComponent, typeof AddFilesBtnComponent, typeof HtmlRawEditorComponent, typeof CustomWidgetEditorComponent, typeof RichTextToHtmlPipe, typeof TagToSpanPipe, typeof ToPreviewPipe, typeof ToHtmlBodyTagsPipe, typeof ToPreviewHtmlPipe], [typeof UploadFilesBtnComponent, typeof HtmlViewComponent, typeof XmlTagTableViewComponent, typeof XmlTagViewComponent, typeof XmlTagRichTextViewComponent, typeof XmlTagHtmlViewComponent, typeof XmlTagTextViewComponent, typeof XmlTagHeaderTextViewComponent, typeof XmlTagHeaderInnerTextViewComponent, typeof XmlTagExternalVideoComponent, typeof HtmlRawViewComponent, typeof FileImageTagViewComponent, typeof XmlTagCustomWidgetComponent, typeof HtmlViewComponent, typeof MainEditorComponent, typeof FileIdSelectComponent, typeof TextEditorComponent, typeof ImageEditorComponent, typeof MainEditorBlockComponent, typeof VisualEditorComponent, typeof AddFilesBtnComponent, typeof HtmlRawEditorComponent, typeof CustomWidgetEditorComponent, typeof RichTextToHtmlPipe, typeof TagToSpanPipe, typeof ToPreviewPipe, typeof ToHtmlBodyTagsPipe, typeof ToPreviewHtmlPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CrocoHtmlModule>;
}

declare const CrocoHtmlOptionsToken = "croco-html-options";

/**
 * Сервис для обработки логики разметки
 */
declare class HtmlViewController {
    onScriptCalled(script: string): void;
    scriptCalled: Subject<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlViewController, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HtmlViewController>;
}

export { AddFilesBtnComponent, AngularMaterialTableMethods, BodyTagsExtensions, BootstrapTableMethods, CrocoHtmlFileOptionsService, CrocoHtmlModule, CrocoHtmlOptionsToken, CustomWidgetEditorComponent, CustomWidgetMethods, CustomWidgetTagDataConsts, ExternalVideoEditorComponent, ExternalVideoPlayers, ExternalVideoSupportedTypes, ExternalVideoTagDataConsts, FileIdSelectComponent, FileImageTagDataConsts, FileImageTagViewComponent, FileType, HtmlRawEditorComponent, HtmlRawViewComponent, HtmlViewComponent, HtmlViewController, ImageEditorComponent, ImageMethods, MainEditorBlockComponent, MainEditorComponent, RichTextToHtmlPipe, TableBuilder, TableMethods, TableTypes, TagToSpanPipe, TextEditorComponent, TextMethods, TextSimpleMethods, TextTag, TextTagDataConsts, TextTags, ToHtmlBodyTagsPipe, ToPreviewHtmlPipe, ToPreviewPipe, UploadFilesBtnComponent, VideoMethods, VisualEditorComponent, XmlExtensions, XmlTagCustomWidgetComponent, XmlTagExternalVideoComponent, XmlTagHeaderInnerTextViewComponent, XmlTagHeaderTextViewComponent, XmlTagHtmlViewComponent, XmlTagRichTextViewComponent, XmlTagTableViewComponent, XmlTagTextViewComponent, XmlTagViewComponent, defaultLinkForDownload, defaultLinkVk, defaultLinkYouTube };
export type { AngularMaterialTableData, BaseApiResponse, CrocoHtmlEditorFileOptions, CrocoHtmlOptions, CustomWidgetTag, CustomWidgetTagData, ExternalVideoTag, ExternalVideoTagData, FileImageTag, FileImageTagData, FilePostingStarted, FileRelationModel, FileSimpleModel, FileUnifiedModel, GenericTextTag, GetListResult, GetListSearchModel, HtmlBodyTag, IMediaRequest, ImageRestrictions, LineBreakBlock, RichTextData, SearchFilesRequest, SearchQuestionsFormData, SimpleTextTag, SimpleTextTagData, TableData, TableHeaderData, TableRowColumnData, TableRowData, TableTagData, TagItem, TextBlock };