/**
 * The current user of this superdoc
 */
export type User = {
    /**
     * The user's name
     */
    name: string;
    /**
     * The user's email
     */
    email: string;
    /**
     * The user's photo
     */
    image?: string | null | undefined;
};
/**
 * Telemetry configuration
 */
export type TelemetryConfig = {
    /**
     * Whether telemetry is enabled
     */
    enabled?: boolean | undefined;
    /**
     * The licence key for telemetry
     */
    licenseKey?: string | undefined;
    /**
     * The endpoint for telemetry
     */
    endpoint?: string | undefined;
    /**
     * The version of the superdoc
     */
    superdocVersion?: string | undefined;
};
export type Document = {
    /**
     * The ID of the document
     */
    id?: string | undefined;
    /**
     * The type of the document
     */
    type: string;
    /**
     * The initial data of the document (File, Blob, or null)
     */
    data?: File | Blob | null | undefined;
    /**
     * The name of the document
     */
    name?: string | undefined;
    /**
     * The URL of the document
     */
    url?: string | undefined;
    /**
     * Whether the document is a new file
     */
    isNewFile?: boolean | undefined;
    /**
     * The Yjs document for collaboration
     */
    ydoc?: import("yjs").Doc | undefined;
    /**
     * The provider for collaboration
     */
    provider?: import("@hocuspocus/provider").HocuspocusProvider | undefined;
};
/**
 * External collaboration provider interface
 * Accepts any Yjs-compatible provider (HocuspocusProvider, LiveblocksYjsProvider, TiptapCollabProvider, etc.)
 */
export type CollaborationProvider = {
    /**
     * The Yjs awareness instance (optional, may be null)
     */
    awareness?: Object | undefined;
    /**
     * Event listener
     */
    on?: ((event: string, handler: Function) => void) | undefined;
    /**
     * Event unsubscriber
     */
    off?: ((event: string, handler: Function) => void) | undefined;
    /**
     * Disconnect from the provider
     */
    disconnect?: (() => void) | undefined;
    /**
     * Destroy the provider
     */
    destroy?: (() => void) | undefined;
    /**
     * Whether the provider has synced
     */
    synced?: boolean | undefined;
    /**
     * Alternative sync property (used by some providers)
     */
    isSynced?: boolean | undefined;
};
/**
 * Collaboration module configuration
 */
export type CollaborationConfig = {
    /**
     * External Yjs document (provider-agnostic mode)
     */
    ydoc?: Object | undefined;
    /**
     * External collaboration provider (provider-agnostic mode)
     */
    provider?: CollaborationProvider | undefined;
    /**
     * Internal provider type (deprecated)
     */
    providerType?: "superdoc" | "hocuspocus" | undefined;
    /**
     * WebSocket URL for internal provider (deprecated)
     */
    url?: string | undefined;
    /**
     * Authentication token for internal provider (deprecated)
     */
    token?: string | undefined;
    /**
     * Additional params for internal provider (deprecated)
     */
    params?: Object | undefined;
};
export type Modules = {
    /**
     * Comments module configuration (false to disable)
     */
    comments?: false | Object | undefined;
    /**
     * Custom permission resolver for comment actions
     */
    permissionResolver?: ((params: {
        permission: string;
        role?: string;
        isInternal?: boolean;
        comment?: Object | null;
        trackedChange?: Object | null;
        currentUser?: User | null;
        superdoc?: SuperDoc | null;
    }) => boolean | undefined) | undefined;
    /**
     * AI module configuration
     */
    ai?: {
        /**
         * Harbour API key for AI features
         */
        apiKey?: string | undefined;
        /**
         * Custom endpoint URL for AI services
         */
        endpoint?: string | undefined;
    } | undefined;
    /**
     * Collaboration module configuration
     */
    collaboration?: CollaborationConfig | undefined;
    /**
     * Toolbar module configuration
     */
    toolbar?: Object | undefined;
    /**
     * Slash menu module configuration
     */
    slashMenu?: {
        /**
         * Array of custom menu sections with items
         */
        customItems?: any[] | undefined;
        /**
         * Function to customize menu items
         */
        menuProvider?: Function | undefined;
        /**
         * Whether to include default menu items
         */
        includeDefaultItems?: boolean | undefined;
    } | undefined;
};
export type Editor = {
    extensionStorage: {};
    presentationEditor: any;
    isFocused: boolean;
    fontsImported: any[];
    options: {
        element: null;
        selector: null;
        isHeadless: boolean;
        mockDocument: null;
        mockWindow: null;
        content: string;
        user: null;
        users: never[];
        media: {};
        mediaFiles: {};
        fonts: {};
        documentMode: string;
        mode: string;
        role: string;
        colors: never[];
        converter: null;
        fileSource: null;
        initialState: null;
        documentId: null;
        extensions: never[];
        editable: boolean;
        editorProps: {};
        parseOptions: {};
        coreExtensionOptions: {};
        enableInputRules: boolean;
        isCommentsEnabled: boolean;
        isNewFile: boolean;
        scale: number;
        annotations: boolean;
        isInternal: boolean;
        externalExtensions: never[];
        isChildEditor: boolean;
        numbering: {};
        isHeaderOrFooter: boolean;
        lastSelection: null;
        suppressDefaultDocxStyles: boolean;
        jsonOverride: null;
        loadFromSchema: boolean;
        fragment: null;
        skipViewCreation: boolean;
        onBeforeCreate: () => null;
        onCreate: () => null;
        onUpdate: () => null;
        onSelectionUpdate: () => null;
        onTransaction: () => null;
        onFocus: () => null;
        onBlur: () => null;
        onDestroy: () => null;
        onContentError: ({ error }: {
            error: any;
        }) => never;
        onTrackedChangesUpdate: () => null;
        onCommentsUpdate: () => null;
        onCommentsLoaded: () => null;
        onCommentClicked: () => null;
        onCommentLocationsUpdate: () => null;
        onDocumentLocked: () => null;
        onFirstRender: () => null;
        onCollaborationReady: () => null;
        onException: () => null;
        onListDefinitionsChange: () => null;
        onFontsResolved: null;
        handleImageUpload: null;
        telemetry: null;
        customUpdatedFiles: {};
        isHeaderFooterChanged: boolean;
        isCustomXmlChanged: boolean;
        ydoc: null;
        collaborationProvider: null;
        collaborationIsReady: boolean;
        shouldLoadComments: boolean;
        replacedFile: boolean;
        focusTarget: null;
        permissionResolver: null;
        parentEditor: null;
    };
    setHighContrastMode: (value: any) => void;
    get docChanged(): boolean;
    mount(el: any): void;
    unmount(): void;
    setToolbar(toolbar: any): void;
    toolbar: any;
    focus(): void;
    readonly state: any;
    get storage(): {};
    get commands(): any;
    readonly helpers: any;
    get isEditable(): boolean;
    readonly isDestroyed: any;
    get element(): null;
    get users(): never[];
    chain(): any;
    can(): any;
    setDocumentMode(documentMode: any, _caller: any): void;
    blur(): void;
    hasFocus(): any;
    coordsAtPos(pos: any): any;
    posAtCoords(coords: any): any;
    generateCollaborationUpdate(): Promise<Uint8Array<ArrayBufferLike>>;
    initializeCollaborationData(): void;
    replaceContent(content: any): void;
    setOptions(options?: {}): void;
    setEditable(editable?: boolean, emitUpdate?: boolean): void;
    registerPlugin(plugin: any, handlePlugins: any): void;
    unregisterPlugin(nameOrPluginKey: any): void;
    getSchemaSummaryJSON(): Promise<{
        version: string;
        schemaVersion: any;
        topNode: any;
        nodes: any[];
        marks: any[];
    }>;
    validateJSON(doc2: any): any;
    createNodeViews(): void;
    getMaxContentSize(): {
        width?: undefined;
        height?: undefined;
    } | {
        width: number;
        height: number;
    };
    updateEditorStyles(element: any, proseMirror: any): void;
    initDefaultStyles(element?: null): void;
    initMobileStyles(element: any): void;
    dispatch(tr: any): void;
    getDocumentIdentifier(): Promise<any>;
    getDocumentGuid(): any;
    isDocumentModified(): any;
    getTelemetryData(): Promise<{
        documentId: any;
        isModified: any;
        isPermanentId: boolean;
        version: any;
    }>;
    getDocumentId(): any;
    getAttributes(nameOrType: any): any;
    isActive(nameOrAttributes: any, attributesOrUndefined: any): boolean;
    getJSON(): any;
    getMetadata(): {
        documentGuid: any;
        isModified: any;
        version: any;
    };
    getHTML({ unflattenLists }?: {
        unflattenLists?: boolean | undefined;
    }): string;
    getMarkdown(): Promise<string>;
    getDocumentVersion(): any;
    createChildEditor(options: any): /*elided*/ any | null;
    getPageStyles(): any;
    updatePageStyle({ pageMargins }: {
        pageMargins: any;
    }): void;
    migrateListsToV2(): any[];
    getUpdatedJson(): any;
    exportDocx({ isFinalDoc, commentsType, exportJsonOnly, exportXmlOnly, comments, getUpdatedDocs, fieldsHighlightColor }?: {
        isFinalDoc?: boolean | undefined;
        commentsType?: string | undefined;
        exportJsonOnly?: boolean | undefined;
        exportXmlOnly?: boolean | undefined;
        comments?: never[] | undefined;
        getUpdatedDocs?: boolean | undefined;
        fieldsHighlightColor?: null | undefined;
    }): Promise<any>;
    destroy(): void;
    destroyHeaderFooterEditors(): void;
    processCollaborationMigrations(): any;
    replaceFile(newFile: any): Promise<void>;
    getInternalXmlFile(name: any, type?: string): any;
    updateInternalXmlFile(name: any, updatedContent: any): void;
    getNodesOfType(type: any): any[];
    replaceNodeWithHTML(targetNode: any, html: any): void;
    prepareForAnnotations(annotationValues?: any[]): void;
    migrateParagraphFields(annotationValues?: any[]): Promise<any[]>;
    annotate(annotationValues?: any[], hiddenIds?: any[], removeEmptyFields?: boolean): void;
    previewAnnotations(annotationValues?: any[], hiddenIds?: any[]): void;
    originalState: any;
    closePreview(): void;
    on(name: any, fn2: any): void;
    emit(name: any, ...args: any[]): void;
    off(name: any, fn2: any): void;
    once(name: any, fn2: any): void;
    removeAllListeners(): void;
};
export type SuperDoc = import("../SuperDoc.js").SuperDoc;
export type DocumentMode = "editing" | "viewing" | "suggesting";
export type ExportType = "docx" | "pdf" | "html";
/**
 * - 'external': Include only external comments (default)
 * - 'clean': Export without any comments
 */
export type CommentsType = "external" | "clean";
export type ExportParams = {
    /**
     * - File formats to export
     */
    exportType?: ExportType[] | undefined;
    /**
     * - How to handle comments
     */
    commentsType?: CommentsType | undefined;
    /**
     * - Custom filename (without extension)
     */
    exportedName?: string | undefined;
    /**
     * - Auto-download or return blob
     */
    triggerDownload?: boolean | undefined;
    /**
     * - Color for field highlights
     */
    fieldsHighlightColor?: string | undefined;
};
export type Config = {
    /**
     * The ID of the SuperDoc
     */
    superdocId?: string | undefined;
    /**
     * The selector or element to mount the SuperDoc into
     */
    selector: string | HTMLElement;
    /**
     * The mode of the document
     */
    documentMode: DocumentMode;
    /**
     * The role of the user in this SuperDoc
     */
    role?: "editor" | "viewer" | "suggester" | undefined;
    /**
     * The document to load. If a string, it will be treated as a URL. If a File or Blob, it will be used directly.
     */
    document?: string | Object | File | Blob | undefined;
    /**
     * The documents to load -> Soon to be deprecated
     */
    documents?: Document[] | undefined;
    /**
     * The current user of this SuperDoc
     */
    user?: User | undefined;
    /**
     * All users of this SuperDoc (can be used for "@"-mentions)
     */
    users?: User[] | undefined;
    /**
     * Colors to use for user awareness
     */
    colors?: string[] | undefined;
    /**
     * Modules to load
     */
    modules?: Modules | undefined;
    /**
     * Top-level override for permission checks
     */
    permissionResolver?: ((params: {
        permission: string;
        role?: string;
        isInternal?: boolean;
        comment?: Object | null;
        trackedChange?: Object | null;
        currentUser?: User | null;
        superdoc?: SuperDoc | null;
    }) => boolean | undefined) | undefined;
    /**
     * Optional DOM element to render the toolbar in
     */
    toolbar?: string | undefined;
    /**
     * Toolbar groups to show
     */
    toolbarGroups?: string[] | undefined;
    /**
     * Icons to show in the toolbar
     */
    toolbarIcons?: Object | undefined;
    /**
     * Texts to override in the toolbar
     */
    toolbarTexts?: Object | undefined;
    /**
     * The font-family to use for all SuperDoc UI surfaces
     * (toolbar, comments UI, dropdowns, tooltips, etc.). This ensures consistent typography across the entire application
     * and helps match your application's design system. The value should be a valid CSS font-family string.
     */
    uiDisplayFallbackFont?: string | undefined;
};
//# sourceMappingURL=index.d.ts.map