import * as _angular_core from '@angular/core';
import { OnDestroy, Signal, ElementRef, AfterViewInit, OnChanges, OnInit, AfterViewChecked, SimpleChanges, InjectionToken, Type, Provider } from '@angular/core';
import * as _angular_platform_browser from '@angular/platform-browser';
import { SafeHtml, SafeResourceUrl } from '@angular/platform-browser';
import { TranslateService } from '@ngx-translate/core';
import * as pdfjs_dist_types_src_display_api from 'pdfjs-dist/types/src/display/api';
import { HttpClient } from '@angular/common/http';
import { PDFDocumentProxy } from 'pdfjs-dist';
import * as PDFJSViewer from 'pdfjs-dist/web/pdf_viewer.mjs';
import * as monaco from 'monaco-editor';

declare class YuvMediaViewerComponent implements OnDestroy {
    #private;
    id: _angular_core.InputSignal<string>;
    type: _angular_core.InputSignal<unknown>;
    metadata: _angular_core.InputSignal<any>;
    src: _angular_core.InputSignal<string | null>;
    extendedData: _angular_core.Signal<any>;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuvMediaViewerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuvMediaViewerComponent, "yuv-media-viewer", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": true; "isSignal": true; }; "metadata": { "alias": "metadata"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface JsonSchemaConfig {
    uri: string;
    schema: any;
    fileMatch?: string[];
}
interface TypeScriptConfig {
    compilerOptions?: any;
    extraLibs?: Array<{
        content: string;
        filePath: string;
    }>;
}
interface DiffConfig {
    enabled: true;
    originalSrc: string;
    modifiedLabel?: string;
    originalLabel?: string;
}
interface MonacoDirectMetadata {
    type: 'monaco-direct';
    theme?: 'dark' | 'light';
    jsonSchema?: JsonSchemaConfig;
    typescript?: TypeScriptConfig;
    diff?: DiffConfig;
    editorOptions?: {
        readOnly?: boolean;
        lineNumbers?: 'on' | 'off' | 'relative' | 'interval';
        minimap?: {
            enabled: boolean;
        };
        wordWrap?: 'on' | 'off' | 'wordWrapColumn' | 'bounded';
        fontSize?: number;
    };
}

interface AudioMetadata {
    type: 'audio';
    mode?: 'oscilloscope' | 'frequency' | 'off';
    disableDocumentPictureInPicture?: boolean;
}
interface VideoMetadata {
    type: 'video';
    disablePictureInPicture?: boolean;
}
interface ImageMetadata {
    type: 'image';
    disableMenu?: boolean;
}
interface EmailDetails {
    subject: string;
    from: string;
    to: string[];
    cc?: string[];
    bcc?: string[];
    sent: Date;
    message: string;
}
type HeaderDetails = Omit<EmailDetails, 'message|send|subject'>;
type Email = Omit<HeaderDetails, 'message'>;
type AttachmentsData = {
    id: string;
    label: string;
    iconRef: SafeHtml;
    icon: string;
};
interface EmailMetadata {
    type: 'EMAIL';
    header: Email;
    attachments: string[];
    theme: string;
}
interface MetadatUser {
    userSettings: {
        locale: string;
    };
    username: string;
    lastname: string;
    firstname: string;
}
interface OfficeMetadata {
    type: 'office';
    id: string;
    dmsObject: Record<string, unknown>;
    editable?: boolean;
    user: MetadatUser;
    sendEvent?: boolean;
    version?: number;
}
interface PdfMetadata {
    type: 'pdf';
    search?: boolean;
    searchTerm?: string;
    theme: string;
}
type Metadata = Partial<AudioMetadata | VideoMetadata | ImageMetadata | EmailMetadata | OfficeMetadata | PdfMetadata | MonacoDirectMetadata>;

declare abstract class AbstractViewerComponent<T extends Record<string, any> = any> {
    type: _angular_core.InputSignal<string | undefined>;
    id: _angular_core.InputSignal<string>;
    metadata: _angular_core.InputSignal<T | undefined>;
    src: _angular_core.InputSignal<string>;
    theme: Signal<'dark' | 'light'>;
    user: Signal<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractViewerComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AbstractViewerComponent<any>, "yuv-abstract", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": true; "isSignal": true; }; "metadata": { "alias": "metadata"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AudioComponent extends AbstractViewerComponent<AudioMetadata> {
    #private;
    imageSrc: _angular_core.Signal<string>;
    get visulisationHeight(): _angular_platform_browser.SafeStyle;
    onWindowResize(): void;
    canvasEle: _angular_core.Signal<ElementRef<HTMLCanvasElement>>;
    audioEle: _angular_core.Signal<ElementRef<HTMLAudioElement>>;
    ctx: _angular_core.Signal<CanvasRenderingContext2D | null>;
    mode: _angular_core.Signal<"off" | "oscilloscope" | "frequency">;
    canvasReadyEffect: _angular_core.AfterRenderRef;
    analyser: AnalyserNode | null;
    bufferLength: number;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AudioComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AudioComponent, "yuv-audio", never, {}, {}, never, never, true, never>;
}

declare class VideoComponent extends AbstractViewerComponent<VideoMetadata> {
    videoEle: _angular_core.Signal<ElementRef<HTMLVideoElement>>;
    imageSrc: _angular_core.Signal<string>;
    isPipSupported: _angular_core.Signal<boolean>;
    enterPictureInPicture(): Promise<PictureInPictureWindow>;
    exitPictureInPicture(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VideoComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VideoComponent, "yuv-video", never, {}, {}, never, never, true, never>;
}

declare class ErrorComponent extends AbstractViewerComponent {
    readonly translate: TranslateService;
    error: _angular_core.InputSignal<"supported" | "notFound" | "authorized">;
    errorMessage: _angular_core.InputSignal<string>;
    errorHandler: _angular_core.Signal<{
        download?: {
            link: string;
            message: any;
        } | undefined;
        error: "supported" | "notFound" | "authorized";
        message: any;
    }>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ErrorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ErrorComponent, "yuv-error", never, { "error": { "alias": "error"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface ActionButton {
    className: string;
    icon: SafeHtml;
    clickAction: () => void;
    ariaLabel: string;
    keyAction: (event: KeyboardEvent, index: number) => void;
}

declare class ImageComponent extends AbstractViewerComponent<ImageMetadata> {
    #private;
    readonly translate: TranslateService;
    image: _angular_core.Signal<ElementRef<HTMLImageElement>>;
    actionButton: _angular_core.Signal<readonly ElementRef<HTMLButtonElement>[]>;
    imageSrc: _angular_core.Signal<string>;
    zoom: _angular_core.WritableSignal<number>;
    startX: _angular_core.WritableSignal<number>;
    startY: _angular_core.WritableSignal<number>;
    rotation: _angular_core.WritableSignal<number>;
    initialX: _angular_core.WritableSignal<number>;
    initialY: _angular_core.WritableSignal<number>;
    isLoading: _angular_core.WritableSignal<boolean>;
    isDragging: _angular_core.WritableSignal<boolean>;
    isImageFocused: _angular_core.WritableSignal<boolean>;
    actionButtons: _angular_core.WritableSignal<ActionButton[]>;
    keyDown(event: KeyboardEvent): void;
    onHostKeyDown(event: MouseEvent): void;
    navigate(event: KeyboardEvent, index: number): void;
    reset(): void;
    rotate(dir: number): void;
    zoomIn(): void;
    zoomOut(): void;
    fakeDrag(key: string): void;
    keybordAction(key: string): void;
    startDrag(event: MouseEvent | TouchEvent): void;
    drag(event: MouseEvent | TouchEvent): void;
    endDrag(): void;
    onKeyDown($event: KeyboardEvent): void;
    onScroll(event: WheelEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImageComponent, "yuv-image", never, {}, {}, never, never, true, never>;
}

interface MediaViewerProvidersOptions {
    office?: {
        path: string;
        reloadOffset?: number;
    };
    einvoice?: {
        saxonJsUrl: string;
    };
}

interface EmlHeaders {
    from: string;
    to: string;
    cc: string;
    bcc: string;
    subject: string;
    date: string;
    replyTo: string;
    messageId: string;
}
interface EmlAttachment {
    filename: string;
    contentType: string;
    size: number;
    dataUrl: string;
    contentId?: string;
}
interface ParsedEml {
    headers: EmlHeaders;
    textBody: string | null;
    htmlBody: string | null;
    attachments: EmlAttachment[];
}

declare class MailComponent extends AbstractViewerComponent<EmailMetadata> {
    #private;
    busyChange: _angular_core.OutputEmitterRef<boolean>;
    protected readonly parsedEmail: _angular_core.WritableSignal<ParsedEml | null>;
    protected readonly activeTab: _angular_core.WritableSignal<"html" | "text">;
    protected readonly fileAttachments: _angular_core.Signal<EmlAttachment[]>;
    protected readonly safeSrcdoc: _angular_core.Signal<SafeHtml | null>;
    protected readonly hasHtmlBody: _angular_core.Signal<boolean>;
    protected readonly hasTextBody: _angular_core.Signal<boolean>;
    file: _angular_core.WritableSignal<File | undefined>;
    fileLoading: _angular_core.Signal<boolean>;
    constructor();
    protected onFileSelected(event: Event): void;
    protected clear(): void;
    protected openAttachment(attachment: EmlAttachment): void;
    protected formatDate(dateStr: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MailComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MailComponent, "yuv-mail", never, {}, { "busyChange": "busyChange"; }, never, never, true, never>;
}

declare class TextComponent extends AbstractViewerComponent<MonacoDirectMetadata> {
    #private;
    contentUrlBlob: _angular_core.WritableSignal<SafeResourceUrl>;
    editorOptions: _angular_core.Signal<{
        language: string;
        theme: string;
    }>;
    content: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextComponent, "yuv-text", never, {}, {}, never, never, true, never>;
}

declare class MonacoDirectComponent extends AbstractViewerComponent<MonacoDirectMetadata> implements AfterViewInit, OnDestroy {
    #private;
    editorContainer: _angular_core.Signal<ElementRef<HTMLDivElement>>;
    content: _angular_core.Signal<string>;
    originalContent: _angular_core.Signal<string>;
    isLoading: _angular_core.Signal<boolean>;
    error: _angular_core.Signal<string | null>;
    isDiffMode: _angular_core.Signal<boolean>;
    language: _angular_core.Signal<string>;
    monacoTheme: _angular_core.Signal<"vs-dark" | "vs-light">;
    editorOptions: _angular_core.Signal<{
        readOnly: boolean;
        lineNumbers?: "on" | "off" | "relative" | "interval";
        minimap: {
            enabled: boolean;
        };
        wordWrap?: "on" | "off" | "wordWrapColumn" | "bounded";
        fontSize?: number;
        language: string;
        theme: string;
        automaticLayout: boolean;
        scrollBeyondLastLine: boolean;
    }>;
    constructor();
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MonacoDirectComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MonacoDirectComponent, "yuv-monaco-direct", never, {}, {}, never, never, true, never>;
}

interface PDFProgressData {
    loaded: number;
    total: number;
}
type ZoomScale = 'page-height' | 'page-fit' | 'page-width';

declare enum RenderTextMode {
    DISABLED = 0,
    ENABLED = 1,
    ENHANCED = 2
}
declare class PdfViewerComponent implements OnChanges, OnInit, OnDestroy, AfterViewChecked {
    #private;
    static CSS_UNITS: number;
    static BORDER_WIDTH: number;
    pdfViewerContainer: _angular_core.Signal<ElementRef<HTMLDivElement>>;
    eventBus: PDFJSViewer.EventBus;
    pdfLinkService: PDFJSViewer.PDFLinkService;
    pdfFindController: PDFJSViewer.PDFFindController;
    pdfViewer: PDFJSViewer.PDFViewer | PDFJSViewer.PDFSinglePageViewer;
    afterLoadComplete: _angular_core.OutputEmitterRef<pdfjs_dist_types_src_display_api.PDFDocumentProxy>;
    pageRendered: _angular_core.OutputEmitterRef<CustomEvent<any>>;
    pageInitialized: _angular_core.OutputEmitterRef<CustomEvent<any>>;
    textLayerRendered: _angular_core.OutputEmitterRef<CustomEvent<any>>;
    pdfError: _angular_core.OutputEmitterRef<any>;
    pdfProgress: _angular_core.OutputEmitterRef<PDFProgressData>;
    pageChangeing: _angular_core.OutputEmitterRef<number>;
    src: _angular_core.InputSignal<string | Uint8Array<ArrayBufferLike> | pdfjs_dist_types_src_display_api.DocumentInitParameters>;
    cMapsUrl: _angular_core.InputSignal<string | null>;
    page: _angular_core.ModelSignal<any>;
    renderText: _angular_core.InputSignal<boolean>;
    renderTextMode: _angular_core.InputSignal<RenderTextMode>;
    originalSize: _angular_core.InputSignal<boolean>;
    showAll: _angular_core.InputSignal<boolean>;
    stickToPage: _angular_core.InputSignal<boolean>;
    zoom: _angular_core.InputSignal<number>;
    zoomScale: _angular_core.InputSignal<ZoomScale>;
    rotation: _angular_core.InputSignalWithTransform<number, number>;
    externalLinkTarget: _angular_core.InputSignal<string>;
    autoresize: _angular_core.InputSignal<boolean>;
    fitTopage: _angular_core.InputSignal<boolean>;
    showBorders: _angular_core.InputSignal<boolean>;
    static getLinkTarget(type: string): any;
    constructor();
    ngAfterViewChecked(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PdfViewerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PdfViewerComponent, "pdf-viewer", never, { "src": { "alias": "src"; "required": true; "isSignal": true; }; "cMapsUrl": { "alias": "c-maps-url"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; "renderText": { "alias": "render-text"; "required": false; "isSignal": true; }; "renderTextMode": { "alias": "render-text-mode"; "required": false; "isSignal": true; }; "originalSize": { "alias": "original-size"; "required": false; "isSignal": true; }; "showAll": { "alias": "show-all"; "required": false; "isSignal": true; }; "stickToPage": { "alias": "stick-to-page"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "zoomScale": { "alias": "zoom-scale"; "required": false; "isSignal": true; }; "rotation": { "alias": "rotation"; "required": false; "isSignal": true; }; "externalLinkTarget": { "alias": "external-link-target"; "required": false; "isSignal": true; }; "autoresize": { "alias": "autoresize"; "required": false; "isSignal": true; }; "fitTopage": { "alias": "fit-to-page"; "required": false; "isSignal": true; }; "showBorders": { "alias": "show-borders"; "required": false; "isSignal": true; }; }, { "afterLoadComplete": "after-load-complete"; "pageRendered": "page-rendered"; "pageInitialized": "pages-initialized"; "textLayerRendered": "text-layer-rendered"; "pdfError": "pdfError"; "pdfProgress": "pdf-progress"; "pageChangeing": "pageChangeing"; "page": "pageChange"; }, never, never, true, never>;
}

interface SearchOptions {
    query: string;
    caseSensitive: boolean;
    wholeWord: boolean;
    highlightAll: boolean;
    matchDiacritics: boolean;
    matchAnyWord: boolean;
    regex: boolean;
    findPrevious: boolean;
}

declare class ToolbarComponent {
    #private;
    page: _angular_core.InputSignal<number>;
    totalPages: _angular_core.InputSignal<number>;
    searchResultCount: _angular_core.ModelSignal<number | null>;
    currentMatchIndex: _angular_core.ModelSignal<number>;
    pdfQuery: _angular_core.ModelSignal<string>;
    searchCaseSensitive: _angular_core.ModelSignal<boolean>;
    searchWholeWord: _angular_core.ModelSignal<boolean>;
    searchHighlightAll: _angular_core.ModelSignal<boolean>;
    searchMatchDiacritics: _angular_core.ModelSignal<boolean>;
    searchMatchAnyWord: _angular_core.ModelSignal<boolean>;
    searchRegex: _angular_core.ModelSignal<boolean>;
    handMode: _angular_core.ModelSignal<boolean>;
    zoomChange: _angular_core.OutputEmitterRef<number>;
    zoomScaleChange: _angular_core.OutputEmitterRef<ZoomScale>;
    rotationChange: _angular_core.OutputEmitterRef<number>;
    pageChange: _angular_core.OutputEmitterRef<number>;
    searchQueryChange: _angular_core.OutputEmitterRef<SearchOptions>;
    readonly width: _angular_core.WritableSignal<number>;
    readonly rotateInMenu: _angular_core.Signal<boolean>;
    readonly zoomInMenu: _angular_core.Signal<boolean>;
    readonly hidePageCount: _angular_core.Signal<boolean>;
    readonly hasOverflow: _angular_core.Signal<boolean>;
    readonly searchOpen: _angular_core.WritableSignal<boolean>;
    readonly searchTrigger: _angular_core.Signal<ElementRef<any> | undefined>;
    readonly overlayPositions: ({
        readonly originX: "end";
        readonly originY: "bottom";
        readonly overlayX: "end";
        readonly overlayY: "top";
        readonly offsetY: 6;
    } | {
        readonly originX: "end";
        readonly originY: "top";
        readonly overlayX: "end";
        readonly overlayY: "bottom";
        readonly offsetY: -6;
    })[];
    constructor();
    toggleSearch(): void;
    openSearch(): void;
    closeSearch(): void;
    onSearchAttached(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolbarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToolbarComponent, "yuv-toolbar", never, { "page": { "alias": "page"; "required": false; "isSignal": true; }; "totalPages": { "alias": "totalPages"; "required": false; "isSignal": true; }; "searchResultCount": { "alias": "searchResultCount"; "required": false; "isSignal": true; }; "currentMatchIndex": { "alias": "currentMatchIndex"; "required": false; "isSignal": true; }; "pdfQuery": { "alias": "pdfQuery"; "required": false; "isSignal": true; }; "searchCaseSensitive": { "alias": "searchCaseSensitive"; "required": false; "isSignal": true; }; "searchWholeWord": { "alias": "searchWholeWord"; "required": false; "isSignal": true; }; "searchHighlightAll": { "alias": "searchHighlightAll"; "required": false; "isSignal": true; }; "searchMatchDiacritics": { "alias": "searchMatchDiacritics"; "required": false; "isSignal": true; }; "searchMatchAnyWord": { "alias": "searchMatchAnyWord"; "required": false; "isSignal": true; }; "searchRegex": { "alias": "searchRegex"; "required": false; "isSignal": true; }; "handMode": { "alias": "handMode"; "required": false; "isSignal": true; }; }, { "searchResultCount": "searchResultCountChange"; "currentMatchIndex": "currentMatchIndexChange"; "pdfQuery": "pdfQueryChange"; "searchCaseSensitive": "searchCaseSensitiveChange"; "searchWholeWord": "searchWholeWordChange"; "searchHighlightAll": "searchHighlightAllChange"; "searchMatchDiacritics": "searchMatchDiacriticsChange"; "searchMatchAnyWord": "searchMatchAnyWordChange"; "searchRegex": "searchRegexChange"; "handMode": "handModeChange"; "zoomChange": "zoomChange"; "zoomScaleChange": "zoomScaleChange"; "rotationChange": "rotationChange"; "pageChange": "pageChange"; "searchQueryChange": "searchQueryChange"; }, never, never, true, never>;
}

declare class PdfComponent extends AbstractViewerComponent implements OnDestroy {
    #private;
    readonly http: HttpClient;
    loadingPdf: _angular_core.WritableSignal<boolean>;
    showToolbar: _angular_core.Signal<any>;
    page: _angular_core.WritableSignal<number>;
    totalPages: _angular_core.WritableSignal<number>;
    zoomOptions: {
        value: number;
        label: string;
    }[];
    error: {
        message: string;
        name: string;
    } | null;
    rotation: _angular_core.WritableSignal<number>;
    zoom: _angular_core.WritableSignal<number>;
    zoomScale: _angular_core.WritableSignal<ZoomScale>;
    originalSize: _angular_core.WritableSignal<boolean>;
    pdf: _angular_core.WritableSignal<pdfjs_dist_types_src_display_api.PDFDocumentProxy | null>;
    renderText: _angular_core.WritableSignal<boolean>;
    progressData: _angular_core.WritableSignal<PDFProgressData | null>;
    isLoaded: _angular_core.WritableSignal<boolean>;
    stickToPage: _angular_core.WritableSignal<boolean>;
    showAll: _angular_core.WritableSignal<boolean>;
    autoresize: _angular_core.WritableSignal<boolean>;
    fitToPage: _angular_core.WritableSignal<boolean>;
    outline: _angular_core.WritableSignal<any[]>;
    isOutlineShown: _angular_core.WritableSignal<boolean>;
    pdfQuery: _angular_core.WritableSignal<string>;
    searchResultCount: _angular_core.WritableSignal<number | null>;
    searchCurrentMatchIndex: _angular_core.WritableSignal<number>;
    searchCaseSensitive: _angular_core.WritableSignal<boolean>;
    searchWholeWord: _angular_core.WritableSignal<boolean>;
    searchHighlightAll: _angular_core.WritableSignal<boolean>;
    searchMatchDiacritics: _angular_core.WritableSignal<boolean>;
    searchMatchAnyWord: _angular_core.WritableSignal<boolean>;
    searchRegex: _angular_core.WritableSignal<boolean>;
    selectedText: _angular_core.WritableSignal<string>;
    handMode: _angular_core.WritableSignal<boolean>;
    pdfComponent: _angular_core.Signal<PdfViewerComponent>;
    toolbarComponent: _angular_core.Signal<ToolbarComponent | undefined>;
    pageAnnouncement: _angular_core.Signal<any>;
    zoomAnnouncement: _angular_core.Signal<any>;
    loadingAnnouncement: _angular_core.Signal<any>;
    validatedSrc: _angular_core.Signal<string | null>;
    constructor();
    /**
     * Handle keyboard events and delegate to shortcuts service
     */
    onKeydown(event: KeyboardEvent): void;
    /**
     * Get pdf information after it's loaded
     * @param pdf pdf document proxy
     */
    afterLoadComplete(pdf: PDFDocumentProxy): void;
    /**
     * Get outline
     */
    loadOutline(): void;
    /**
     * Handle error callback
     *
     * @param error error message
     */
    onError(error: any): void;
    /**
     * Pdf loading progress callback
     * @param progressData pdf progress data
     */
    onProgress(progressData: PDFProgressData): void;
    /**
     * Navigate to destination
     * @param destination pdf navigate to
     */
    navigateTo(destination: any): void;
    /**
     * Page rendered callback, which is called when a page is rendered (called multiple times)
     *
     * @param e custom event
     */
    pageRendered(e: CustomEvent): void;
    /**
     * Page initialized callback.
     *
     * @param {CustomEvent} e
     */
    pageInitialized(e: CustomEvent): void;
    /**
     * Page change callback, which is called when a page is changed (called multiple times)
     *
     * @param e number
     */
    pageChange(e: number): void;
    searchQueryChanged(searchOptions: SearchOptions): void;
    onAnchorKeyup(event: KeyboardEvent, dest: any): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PdfComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PdfComponent, "yuv-pdf", never, {}, {}, never, never, true, never>;
}

/**
 * Configuration options for PDF viewer
 */
interface PdfViewerConfig {
    /**
     * Path to the PDF.js worker file
     * Required for CSP compliance - should point to a local worker file
     * @example '/assets/pdf.worker.min.mjs'
     * @example 'https://your-cdn.com/pdf.worker.min.mjs'
     */
    workerSrc?: string;
    /**
     * Path to the cMaps directory
     * Required for rendering PDFs with CJK (Chinese, Japanese, Korean) characters
     * @example '/assets/cmaps/'
     */
    cMapUrl?: string;
    /**
     * Whether to pack cMaps data
     * @default false
     */
    cMapPacked?: boolean;
    /**
     * Standard font data URL
     * Required for PDFs that use standard fonts
     * @example '/assets/standard_fonts/'
     */
    standardFontDataUrl?: string;
    /**
     * Whether to use only CSS zoom (no canvas scaling)
     * Can improve performance but may reduce quality
     * @default false
     */
    useOnlyCssZoom?: boolean;
    /**
     * Maximum image size in pixels
     * Larger images will be downscaled
     * @default -1 (no limit)
     */
    maxImageSize?: number;
    /**
     * Whether to disable auto-fetch of fonts
     * Set to true for strict CSP environments
     * @default false
     */
    disableFontFace?: boolean;
    /**
     * Whether to disable streaming of PDF data
     * May be required in some CSP environments
     * @default false
     */
    disableStream?: boolean;
    /**
     * Whether to disable range requests
     * May be required in some CSP environments
     * @default false
     */
    disableRange?: boolean;
}
/**
 * Default PDF viewer configuration
 */
declare const DEFAULT_PDF_VIEWER_CONFIG: PdfViewerConfig;
/**
 * Injection token for PDF viewer configuration
 */
declare const PDF_VIEWER_CONFIG: InjectionToken<PdfViewerConfig>;
/**
 * Provides PDF viewer configuration
 * Use this in your app config or module providers
 *
 * @example
 * ```typescript
 * export const appConfig: ApplicationConfig = {
 *   providers: [
 *     providePdfViewerConfig({
 *       workerSrc: '/assets/pdf.worker.min.mjs',
 *       cMapUrl: '/assets/cmaps/',
 *       cMapPacked: true
 *     })
 *   ]
 * };
 * ```
 */
declare function providePdfViewerConfig(config: PdfViewerConfig): {
    provide: InjectionToken<PdfViewerConfig>;
    useValue: {
        workerSrc?: string;
        cMapUrl?: string;
        cMapPacked?: boolean;
        standardFontDataUrl?: string;
        useOnlyCssZoom?: boolean;
        maxImageSize?: number;
        disableFontFace?: boolean;
        disableStream?: boolean;
        disableRange?: boolean;
    };
};

/**
 * Security configuration for PDF viewer
 */
interface PdfSecurityConfig {
    /**
     * List of allowed URL protocols
     * @default ['http:', 'https:', 'blob:', 'data:']
     */
    allowedProtocols?: string[];
    /**
     * List of allowed domains for PDF loading
     * If specified, only PDFs from these domains will be loaded
     * @example ['example.com', 'cdn.example.com']
     */
    allowedDomains?: string[];
    /**
     * Whether to allow data URLs
     * @default true
     */
    allowDataUrls?: boolean;
    /**
     * Whether to allow blob URLs
     * @default true
     */
    allowBlobUrls?: boolean;
    /**
     * Maximum PDF file size in bytes
     * @default -1 (no limit)
     */
    maxFileSize?: number;
}
/**
 * Service for validating and sanitizing PDF sources
 * Prevents XSS attacks and ensures safe PDF loading
 */
declare class PdfSecurityService {
    #private;
    private readonly DEFAULT_ALLOWED_PROTOCOLS;
    private config;
    /**
     * Configure security settings
     */
    configure(config: PdfSecurityConfig): void;
    /**
     * Validate a URL for PDF loading
     * @param url URL to validate
     * @returns true if URL is safe, false otherwise
     */
    validateUrl(url: string): boolean;
    /**
     * Sanitize a URL for safe use
     * @param url URL to sanitize
     * @returns Sanitized URL or null if invalid
     */
    sanitizeUrl(url: string): SafeResourceUrl | null;
    /**
     * Validate PDF source (URL, Blob, or ArrayBuffer)
     * @param source PDF source to validate
     * @returns true if source is valid, false otherwise
     */
    validateSource(source: any): boolean;
    /**
     * Get current security configuration
     */
    getConfig(): Readonly<PdfSecurityConfig>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PdfSecurityService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PdfSecurityService>;
}

declare class OfficeComponent extends AbstractViewerComponent<OfficeMetadata> {
    #private;
    readonly environmentData: {
        office: {
            path: string;
            reloadOffset: number;
        };
    };
    timeTrigger: _angular_core.WritableSignal<string | null>;
    isDocumentUpdating: _angular_core.WritableSignal<boolean>;
    params: {
        name: string;
    };
    downloadPath: string | null;
    dashletIsLoading: _angular_core.Signal<boolean>;
    dashletIsAvailable: _angular_core.WritableSignal<boolean | undefined>;
    onMessage(event: MessageEvent): void;
    srcPath: _angular_core.Signal<string | null>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OfficeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OfficeComponent, "yuv-office", never, {}, {}, never, never, true, never>;
}

declare enum DASHLET_MESSAGE_EVENTS {
    OFFICE_DOCUMENT_UPDATE = "yuv.office.document.update",
    OFFICE_DOCUMENT_CONVERTED = "yuv.office.document.converted",
    OFFICE_DOCUMENT_UNKNOWN = "yuv.office.document.unknown"
}

declare class OpenOfficeComponent extends AbstractViewerComponent {
    renditionSrc: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OpenOfficeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OpenOfficeComponent, "app-open-office", never, {}, {}, never, never, true, never>;
}

declare class EInvoiceComponent extends AbstractViewerComponent implements OnInit {
    #private;
    invoiceHtml: _angular_core.WritableSignal<SafeResourceUrl | null>;
    isLoading: _angular_core.Signal<boolean>;
    frame: _angular_core.Signal<ElementRef<HTMLIFrameElement>>;
    ngOnInit(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EInvoiceComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EInvoiceComponent, "yuv-e-invoice", never, {}, {}, never, never, true, never>;
}

type Viewer = {
    mimeType: string[];
    type: KeyTypes;
};
type KeyTypes = 'VIDEO' | 'TEXT' | 'EMAIL' | 'ERROR' | 'IMAGE' | 'MONACO' | 'MONACO_DIRECT' | 'PDF' | 'OFFICE' | 'OPENOFFICE' | Uppercase<string>;
type TypedComponents = {
    [K in KeyTypes]: {
        [key in K]: Type<any>;
    };
}[KeyTypes];
declare const defaultViewers: Array<Viewer>;

declare class MediaViewerService {
    #private;
    defaultViewers: _angular_core.WritableSignal<Viewer[]>;
    defaultComponents: _angular_core.WritableSignal<{
        [x: Uppercase<string>]: Type<any>;
    }>;
    width: _angular_core.Signal<number>;
    height: _angular_core.Signal<number>;
    /** Returns the viewer type key for a given MIME type, falling back to `'ERROR'` if no match is found. */
    getComponentType(type: string): KeyTypes;
    /**
     * Adds one or more custom viewer mappings to the viewer list.
     * Any MIME types present in the incoming viewer(s) are first removed from existing entries
     * so that the new mapping takes precedence without duplicates.
     * Empty entries are pruned, except for the `ERROR` fallback entry.
     */
    setViewers(customViewer: Viewer | Viewer[]): void;
    /** Resets the viewer list to the original default mappings. */
    resetViewers(): void;
    /** Registers one or more custom viewer components, keyed by their viewer type. */
    setCustomViewer(components: TypedComponents | TypedComponents[]): void;
    /**
     * Convenience method to register both a MIME-type mapping and its corresponding component in one call.
     * Equivalent to calling `setViewers()` followed by `setCustomViewer()`.
     */
    extendViewer<T = undefined>(customViewer: Viewer, component: Type<T>): void;
    /** Stores the current viewer container dimensions used for layout calculations. */
    setViewerSeize(width: number, height: number): void;
    /** Extracts and returns the lowercase file extension from a filename, or an empty string if none is found. */
    fileExtension(fileName: string | null): string;
    /** Builds the full content URL for a DMS object, optionally targeting a specific version. */
    srcPath(id: string, officeEnv: {
        path: string;
        reloadOffset: number;
    }, version: number | undefined): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MediaViewerService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MediaViewerService>;
}

declare const provideMediaViewer: (options?: MediaViewerProvidersOptions | null) => Provider;

interface MonacoLoaderState {
    status: 'idle' | 'loading' | 'loaded' | 'error';
    error?: string;
}
declare class MonacoLoaderService {
    #private;
    state: _angular_core.Signal<MonacoLoaderState>;
    /**
     * Loads Monaco editor AMD loader and initializes the environment.
     * Returns a Promise that resolves with the global monaco object.
     */
    loadMonaco(): Promise<typeof monaco>;
    /**
     * Configure JSON schema for IntelliSense
     */
    configureJsonSchema(uri: string, schema: any, fileMatch?: string[]): void;
    /**
     * Configure TypeScript compiler options
     */
    configureTypeScript(options: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MonacoLoaderService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MonacoLoaderService>;
}

declare const ENVIRONMENT_DATA_DEFAULT: MediaViewerProvidersOptions;
declare const ENVIRONMENT_DATA: InjectionToken<MediaViewerProvidersOptions>;

export { AbstractViewerComponent, AudioComponent, DASHLET_MESSAGE_EVENTS, DEFAULT_PDF_VIEWER_CONFIG, EInvoiceComponent, ENVIRONMENT_DATA, ENVIRONMENT_DATA_DEFAULT, ErrorComponent, ImageComponent, MailComponent, MediaViewerService, MonacoDirectComponent, MonacoLoaderService, OfficeComponent, OpenOfficeComponent, PDF_VIEWER_CONFIG, PdfComponent, PdfSecurityService, TextComponent, VideoComponent, YuvMediaViewerComponent, defaultViewers, provideMediaViewer, providePdfViewerConfig };
export type { AttachmentsData, AudioMetadata, DiffConfig, Email, EmailDetails, EmailMetadata, HeaderDetails, ImageMetadata, JsonSchemaConfig, KeyTypes, MediaViewerProvidersOptions, MetadatUser, Metadata, MonacoDirectMetadata, OfficeMetadata, PdfMetadata, PdfSecurityConfig, PdfViewerConfig, TypeScriptConfig, TypedComponents, VideoMetadata, Viewer };