/**
 * Embeddable viewer/editor entry point — the CDN story.
 *
 * This module packages the whole stack behind two one-call factories so a page
 * can embed a DOCX viewer or editor with a single script tag and no build step:
 *
 * ```html
 * <div id="doc"></div>
 * <script type="module">
 *   import { createViewer } from "https://cdn.jsdelivr.net/npm/docxodus@9.1.1/dist/embed.bundle.js";
 *   await createViewer("#doc", "./contract.docx");
 * </script>
 * ```
 *
 * It ships in three shapes (see package.json build scripts):
 *  - `dist/embed.js`         — plain ESM with relative imports, for bundler users
 *                              (`import { createEditor } from "docxodus/embed"`).
 *                              Shares module state with the main `docxodus` entry.
 *  - `dist/embed.bundle.js`  — self-contained ESM bundle for CDN `<script type="module">`.
 *  - `dist/embed.iife.js`    — classic-script bundle exposing `window.Docxodus`.
 *
 * WASM asset resolution: the .NET runtime files live in `wasm/` next to this
 * file (`dist/wasm/` in the published package), which auto-resolves through
 * `import.meta.url` in the ESM shapes. The IIFE shape has no `import.meta`, so
 * it falls back to `document.currentScript.src` captured at load time. An
 * explicit `wasmBasePath` option always wins.
 */
import { DocxEditor } from "./editor.js";
import type { DocxEditorOptions } from "./editor.js";
import type { RibbonEditor, RibbonOptions } from "./ribbon.js";
import type { ConversionOptions } from "./types.js";
export * from "./index.js";
export { DocxEditor } from "./editor.js";
export type { DocxEditorExports, DocxEditorOptions } from "./editor.js";
/**
 * A document to load: raw bytes, a Blob/File (e.g. from an <input type="file">),
 * or a URL string to fetch (must be same-origin or CORS-readable).
 */
export type DocumentSource = Uint8Array | ArrayBuffer | Blob | string;
/** Normalize any DocumentSource to bytes. */
export declare function toDocumentBytes(source: DocumentSource): Promise<Uint8Array>;
export interface DocxViewerOptions extends ConversionOptions {
    /** Explicit URL of the wasm assets directory; omit to auto-detect. */
    wasmBasePath?: string;
}
export interface DocxViewer {
    /** The container the document was rendered into. */
    readonly element: HTMLElement;
    /** The full HTML document string the converter produced. */
    readonly html: string;
    /** Re-render a (new) document into the same container. */
    reload(source: DocumentSource, options?: ConversionOptions): Promise<void>;
    /** Empty the container. */
    destroy(): void;
}
/**
 * Render a read-only DOCX viewer into `container`.
 *
 * Injects the converter's stylesheet plus the document body into the container
 * (the same mounting the editor uses), so the page's own styles are untouched.
 * Footnotes/endnotes render by default — they are document content; override
 * any conversion option via `options`.
 */
export declare function createViewer(container: string | HTMLElement, source: DocumentSource, options?: DocxViewerOptions): Promise<DocxViewer>;
export interface CreateEditorOptions extends DocxEditorOptions {
    /** Explicit URL of the wasm assets directory; omit to auto-detect. */
    wasmBasePath?: string;
}
/**
 * Open an editable DOCX editor in `container`.
 *
 * With a `source`, opens that document; without one, opens a blank "New
 * document". Returns the `DocxEditor` instance — `save()` for the edited
 * bytes, `close()` to release the WASM session, plus the full command surface
 * (formatting, tables, notes, headers/footers, undo/redo).
 */
export declare function createEditor(container: string | HTMLElement, source?: DocumentSource | null, options?: CreateEditorOptions): Promise<DocxEditor>;
export interface CreateRibbonEditorOptions extends RibbonOptions {
    /** Explicit URL of the wasm assets directory; omit to auto-detect. */
    wasmBasePath?: string;
}
/**
 * Open the FULL editor surface — ribbon chrome, anchor rail and all — in one call.
 *
 * `createEditor` gives you a bare editable document and leaves the UI to you.
 * This gives you the whole instrument, which is what the shipped demo pages use:
 *
 * ```html
 * <div id="app" style="height:100dvh"></div>
 * <script type="module">
 *   import { createRibbonEditor } from "https://cdn.jsdelivr.net/npm/docxodus/dist/embed.bundle.js";
 *   await createRibbonEditor("#app", "./contract.docx");
 * </script>
 * ```
 *
 * The chrome (and its loading overlay) paint immediately; the .NET runtime streams
 * behind them, and the overlay narrates that wait instead of hiding it. Density
 * follows the CONTAINER's width, so the same call serves a full-page editor and a
 * narrow embedded panel.
 */
export declare function createRibbonEditor(container: string | HTMLElement, source?: DocumentSource | null, options?: CreateRibbonEditorOptions): Promise<RibbonEditor>;
//# sourceMappingURL=embed.d.ts.map