import { Node } from 'prosemirror-model';
import { C as Comment } from '../content-aR2R8xzY.js';
import { Document } from '../types/document.js';
import { E as ExternalMediaManifestEntry } from '../styles-CMw21pSP.js';
import '../formatting-JhqWT_XM.js';
import '../colors-C3vA7HUU.js';
import '../docx/wrapTypes.js';
import '../lists-Bn29SzeS.js';
import '../watermark-CWDb_V8x.js';

interface CollaborationJsonMark {
    type: string;
    attrs?: Record<string, unknown>;
}
interface CollaborationJsonNode {
    type: string;
    attrs?: Record<string, unknown>;
    content?: CollaborationJsonNode[];
    marks?: CollaborationJsonMark[];
    text?: string;
}
interface CollaborationProjectionOptions {
    baseRevision: string;
    schemaVersion?: number;
}
interface CollaborationDiagnostic {
    code: 'image_asset_id_missing' | 'sidecar_entry_mismatch';
    severity: 'error' | 'warning';
    nodeType: string;
}
interface CollaborationProjectionStats {
    sourceJsonBytes: number;
    projectedJsonBytes: number;
    sidecarJsonBytes: number;
    mediaReferenceCount: number;
    strippedAttributeCount: number;
}
interface CollaborationProjection {
    schemaVersion: number;
    baseRevision: string;
    document: CollaborationJsonNode;
    sidecar: FidelitySidecar;
    diagnostics: CollaborationDiagnostic[];
    stats: CollaborationProjectionStats;
}
interface FidelitySidecarEntry {
    nodeType: string;
    attrs: Record<string, unknown>;
}
interface FidelitySidecar {
    version: 1;
    baseRevision: string;
    entries: Record<string, FidelitySidecarEntry>;
}
interface ParsedCollaborationPackage {
    document: Document;
    projection: CollaborationProjection;
}
interface CollaborationExportAsset {
    assetId: string;
    mimeType: string;
    bytes: Uint8Array;
}
interface CollaborationExportInput {
    sourceBuffer: ArrayBuffer;
    sourceSha256: string;
    baseRevision: string;
    manifest: readonly ExternalMediaManifestEntry[];
    projectedDocument: CollaborationJsonNode;
    sidecar: FidelitySidecar;
    /**
     * Current controlled comment threads. Omit only when the caller does not
     * manage comments; an explicit empty array removes all comments.
     */
    comments?: readonly Comment[];
    assets?: readonly CollaborationExportAsset[];
}
interface ProseMirrorProjectionInput {
    document: Node;
    options: CollaborationProjectionOptions;
}

declare function rehydrateCollaborationDocument(document: CollaborationJsonNode, sidecar: FidelitySidecar, diagnostics?: CollaborationDiagnostic[]): CollaborationJsonNode;

declare function projectProseMirrorDocument(document: Node, options: CollaborationProjectionOptions): CollaborationProjection;

type CollaborationExportFidelityFailure = 'structural_change' | 'untracked_paragraph_change' | 'unsafe_paragraph_markup' | 'xml_patch_failed';
declare class CollaborationExportFidelityError extends Error {
    readonly code = "collaboration_export_fidelity_unsupported";
    readonly reason: CollaborationExportFidelityFailure;
    readonly paragraphId?: string;
    constructor(reason: CollaborationExportFidelityFailure, paragraphId?: string);
}

declare class MissingCollaborationAssetError extends Error {
    readonly code = "missing_collaboration_asset";
    readonly assetId: string;
    constructor(assetId: string);
}
declare class CollaborationIdentityMismatchError extends Error {
    readonly code = "collaboration_identity_mismatch";
    constructor();
}
declare class IncompleteCollaborationManifestError extends Error {
    readonly code = "incomplete_collaboration_manifest";
    readonly missingPaths: readonly string[];
    constructor(missingPaths?: readonly string[]);
}
declare function parseCollaborationPackage(input: {
    packageBuffer: ArrayBuffer;
    manifest: readonly ExternalMediaManifestEntry[];
    baseRevision: string;
}): Promise<ParsedCollaborationPackage>;
/**
 * Worker-safe full-fidelity export. The immutable source package is loaded
 * only inside the caller's document worker, then discarded with that worker.
 */
declare function exportCollaborationDocument(input: CollaborationExportInput): Promise<ArrayBuffer>;

export { type CollaborationDiagnostic, type CollaborationExportAsset, CollaborationExportFidelityError, type CollaborationExportFidelityFailure, type CollaborationExportInput, CollaborationIdentityMismatchError, type CollaborationJsonMark, type CollaborationJsonNode, type CollaborationProjection, type CollaborationProjectionOptions, type CollaborationProjectionStats, type FidelitySidecar, type FidelitySidecarEntry, IncompleteCollaborationManifestError, MissingCollaborationAssetError, type ParsedCollaborationPackage, type ProseMirrorProjectionInput, exportCollaborationDocument, parseCollaborationPackage, projectProseMirrorDocument, rehydrateCollaborationDocument };