js.documents 0.0.0 → 1.54.0

package/dist/index.d.ts

@@ -0,0 +1,1407 @@
+import { Attribute, AttributeSchema, BinaryPart, BinaryPartSchema, Comment, CommentSchema, CompactAttrPairs, CompactPackage, CompactPackageSchema, CompactPart, CompactPartSchema, CompactXmlNode, CompactXmlNodeSchema, DefinedName, DefinedNameSchema, Package, Package as Package$1, PackageSchema, Part, PartSchema, Relationship, XmlCdata, XmlCdataSchema, XmlComment, XmlCommentSchema, XmlDeclaration, XmlDeclarationSchema, XmlElement, XmlElement as XmlElement$1, XmlElementSchema, XmlNode, XmlNode as XmlNode$1, XmlNodeSchema, XmlPart, XmlPartSchema, XmlPi, XmlPiSchema, XmlText, XmlTextSchema, attr, base64ToBytes, buildXml, bytesToBase64, childrenWithTag, compactCodec, compactPackageCodec, decodeCompactPackage, decodeEntities, decodePackage, elementsWithTag, encodeCompactPackage, encodePackage, fromCompact, isCompactXmlNode, isXmlNode, packageCodec, parsePackage, parseXml, resolveRelationships, rootElement, serializePackage, textContent as textContent$1, toCompact, unzipPackage, walk, xmlCodec, zipPackage } from "ooxml.js";
+import { Alignment, Box, Box as Box$1, COLOR_BLACK, Color, Color as LayoutColor, ContentBlock, ContentBlockSchema, ContentCellValue, ContentCellValue as ContentCellValue$1, ContentCellValueSchema, ContentDrawPage, ContentDrawPageSchema, ContentImageBlock, ContentImageBlockSchema, ContentListMembership, ContentListMembership as ContentListMembership$1, ContentPageBreak, ContentPageBreakSchema, ContentParagraph, ContentParagraphSchema, ContentPathPoint, ContentPathPoint as ContentPathPoint$1, ContentPathPointSchema, ContentPathSegment, ContentPathSegmentSchema, ContentRun, ContentRun as ContentRun$1, ContentRunSchema, ContentSection, ContentSectionSchema, ContentShape, ContentShapeSchema, ContentSheet, ContentSheetCell, ContentSheetCellSchema, ContentSheetColumn, ContentSheetColumnSchema, ContentSheetImage, ContentSheetPrintRange, ContentSheetPrintRangeSchema, ContentSheetPrintSettings, ContentSheetPrintSettings as ContentSheetPrintSettings$1, ContentSheetPrintSettingsSchema, ContentSheetRepeatRange, ContentSheetRepeatRangeSchema, ContentSheetRow, ContentSheetRowSchema, ContentSheetSchema, ContentSlide, ContentSlideSchema, ContentStroke, ContentStroke as ContentStroke$1, ContentStrokeSchema, ContentSubpath, ContentSubpath as ContentSubpath$1, ContentSubpathSchema, ContentTable, ContentTableCell, ContentTableCellSchema, ContentTableRow, ContentTableRowSchema, ContentTableSchema, ContentVector, ContentVectorSchema, DEFAULT_LAYOUT_FONT, DocumentPackage, LAYOUT_FORMAT_VERSION, LayoutDocument, LayoutDocument as LayoutDocument$1, LayoutEllipse, LayoutFont, LayoutImage, LayoutImageAsset, LayoutItem, LayoutLine, LayoutLink, LayoutMetadata, LayoutMetadata as LayoutMetadata$1, LayoutPage, LayoutPath, LayoutPathSegment, LayoutRect, LayoutSubpath, LayoutText, Margins, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PageSize, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN, isContentBlock, rgbHexToColor } from "document-content-model";
+import { z } from "zod";
+import { Package as Package$2, XmlElement as XmlElement$2, XmlNode as XmlNode$2 } from "odf.js";
+import { LoadedMathFont, MathFont, MathFontDescriptorMetrics, NOOP_DIAGNOSTIC_SINK, PdfDiagnostic, PdfDiagnosticSeverity, PdfDiagnosticSink, PdfDiagnosticSink as PdfDiagnosticSink$1, PdfEncryptedError, PdfParseError, PositionedFormula, PositionedFormula as PositionedFormula$1, ReadPdfOptions, TextMeasurer, WinAnsiSubstitution, WinAnsiSubstitution as WinAnsiSubstitution$1, WritePdfOptions, loadMathFont, pdfCodec, readPdf, writePdf } from "pdf-codec";
+//#region src/model/content.d.ts
+declare const CONTENT_FORMAT_VERSION = 1;
+declare const ContentDocumentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"wordprocessing">;
+  formatVersion: z.ZodLiteral<1>;
+  metadata: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    creator: z.ZodOptional<z.ZodString>;
+    producer: z.ZodOptional<z.ZodString>;
+    createdIso: z.ZodOptional<z.ZodString>;
+    modifiedIso: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  sections: z.ZodArray<z.ZodObject<{
+    pageSize: z.ZodObject<{
+      widthPt: z.ZodNumber;
+      heightPt: z.ZodNumber;
+    }, z.core.$strip>;
+    margins: z.ZodObject<{
+      topPt: z.ZodNumber;
+      rightPt: z.ZodNumber;
+      bottomPt: z.ZodNumber;
+      leftPt: z.ZodNumber;
+    }, z.core.$strip>;
+    blocks: z.ZodArray<z.ZodCustom<import("document-content-model").ContentBlock, import("document-content-model").ContentBlock>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"presentation">;
+  formatVersion: z.ZodLiteral<1>;
+  metadata: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    creator: z.ZodOptional<z.ZodString>;
+    producer: z.ZodOptional<z.ZodString>;
+    createdIso: z.ZodOptional<z.ZodString>;
+    modifiedIso: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  slides: z.ZodArray<z.ZodObject<{
+    size: z.ZodObject<{
+      widthPt: z.ZodNumber;
+      heightPt: z.ZodNumber;
+    }, z.core.$strip>;
+    shapes: z.ZodArray<z.ZodObject<{
+      name: z.ZodOptional<z.ZodString>;
+      frame: z.ZodObject<{
+        xPt: z.ZodNumber;
+        yPt: z.ZodNumber;
+        widthPt: z.ZodNumber;
+        heightPt: z.ZodNumber;
+      }, z.core.$strip>;
+      rotationDeg: z.ZodOptional<z.ZodNumber>;
+      insetLeftPt: z.ZodNumber;
+      insetTopPt: z.ZodNumber;
+      insetRightPt: z.ZodNumber;
+      insetBottomPt: z.ZodNumber;
+      fontScale: z.ZodOptional<z.ZodNumber>;
+      lineSpacingReduction: z.ZodOptional<z.ZodNumber>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+      blocks: z.ZodArray<z.ZodCustom<import("document-content-model").ContentBlock, import("document-content-model").ContentBlock>>;
+    }, z.core.$strip>>;
+    notes: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"spreadsheet">;
+  formatVersion: z.ZodLiteral<1>;
+  metadata: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    creator: z.ZodOptional<z.ZodString>;
+    producer: z.ZodOptional<z.ZodString>;
+    createdIso: z.ZodOptional<z.ZodString>;
+    modifiedIso: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  sheets: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    cells: z.ZodArray<z.ZodObject<{
+      row: z.ZodNumber;
+      column: z.ZodNumber;
+      value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"number">;
+        value: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"percentage">;
+        value: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"currency">;
+        value: z.ZodNumber;
+        currency: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"boolean">;
+        value: z.ZodBoolean;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"date">;
+        value: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"time">;
+        value: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"string">;
+        value: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"error">;
+        value: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"empty">;
+      }, z.core.$strip>], "kind">;
+      formula: z.ZodOptional<z.ZodString>;
+      displayText: z.ZodString;
+      runs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        bold: z.ZodOptional<z.ZodBoolean>;
+        italic: z.ZodOptional<z.ZodBoolean>;
+        underline: z.ZodOptional<z.ZodBoolean>;
+        strike: z.ZodOptional<z.ZodBoolean>;
+        fontFamily: z.ZodOptional<z.ZodString>;
+        sizePt: z.ZodOptional<z.ZodNumber>;
+        color: z.ZodOptional<z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>>;
+        hyperlink: z.ZodOptional<z.ZodString>;
+        sourcePath: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>>;
+      colSpan: z.ZodOptional<z.ZodNumber>;
+      rowSpan: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    columns: z.ZodArray<z.ZodObject<{
+      index: z.ZodNumber;
+      widthPt: z.ZodNumber;
+      hidden: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    rows: z.ZodArray<z.ZodObject<{
+      index: z.ZodNumber;
+      heightPt: z.ZodNumber;
+      hidden: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    images: z.ZodArray<z.ZodObject<{
+      kind: z.ZodLiteral<"image">;
+      format: z.ZodEnum<{
+        png: "png";
+        jpeg: "jpeg";
+      }>;
+      base64: z.ZodString;
+      widthPt: z.ZodNumber;
+      heightPt: z.ZodNumber;
+      altText: z.ZodOptional<z.ZodString>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+      anchorRow: z.ZodNumber;
+      anchorColumn: z.ZodNumber;
+      offsetXPt: z.ZodNumber;
+      offsetYPt: z.ZodNumber;
+    }, z.core.$strip>>;
+    printSettings: z.ZodObject<{
+      pageSize: z.ZodObject<{
+        widthPt: z.ZodNumber;
+        heightPt: z.ZodNumber;
+      }, z.core.$strip>;
+      margins: z.ZodObject<{
+        topPt: z.ZodNumber;
+        rightPt: z.ZodNumber;
+        bottomPt: z.ZodNumber;
+        leftPt: z.ZodNumber;
+      }, z.core.$strip>;
+      printRange: z.ZodOptional<z.ZodObject<{
+        startRow: z.ZodNumber;
+        startColumn: z.ZodNumber;
+        endRow: z.ZodNumber;
+        endColumn: z.ZodNumber;
+      }, z.core.$strip>>;
+      scale: z.ZodOptional<z.ZodNumber>;
+      fitToPages: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$strip>>;
+      repeatRows: z.ZodOptional<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+      }, z.core.$strip>>;
+      repeatColumns: z.ZodOptional<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+      }, z.core.$strip>>;
+      gridlines: z.ZodBoolean;
+      headers: z.ZodBoolean;
+      pageOrder: z.ZodEnum<{
+        downThenOver: "downThenOver";
+        overThenDown: "overThenDown";
+      }>;
+      manualBreaks: z.ZodOptional<z.ZodObject<{
+        rows: z.ZodArray<z.ZodNumber>;
+        columns: z.ZodArray<z.ZodNumber>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    embeddedObjects: z.ZodOptional<z.ZodArray<z.ZodCustom<import("document-content-model").ContentEmbeddedObject, import("document-content-model").ContentEmbeddedObject>>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"drawing">;
+  formatVersion: z.ZodLiteral<1>;
+  metadata: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    creator: z.ZodOptional<z.ZodString>;
+    producer: z.ZodOptional<z.ZodString>;
+    createdIso: z.ZodOptional<z.ZodString>;
+    modifiedIso: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  pages: z.ZodArray<z.ZodObject<{
+    size: z.ZodObject<{
+      widthPt: z.ZodNumber;
+      heightPt: z.ZodNumber;
+    }, z.core.$strip>;
+    shapes: z.ZodArray<z.ZodObject<{
+      name: z.ZodOptional<z.ZodString>;
+      frame: z.ZodObject<{
+        xPt: z.ZodNumber;
+        yPt: z.ZodNumber;
+        widthPt: z.ZodNumber;
+        heightPt: z.ZodNumber;
+      }, z.core.$strip>;
+      rotationDeg: z.ZodOptional<z.ZodNumber>;
+      insetLeftPt: z.ZodNumber;
+      insetTopPt: z.ZodNumber;
+      insetRightPt: z.ZodNumber;
+      insetBottomPt: z.ZodNumber;
+      fontScale: z.ZodOptional<z.ZodNumber>;
+      lineSpacingReduction: z.ZodOptional<z.ZodNumber>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+      blocks: z.ZodArray<z.ZodCustom<import("document-content-model").ContentBlock, import("document-content-model").ContentBlock>>;
+    }, z.core.$strip>>;
+    vectors: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"rect">;
+      frame: z.ZodObject<{
+        xPt: z.ZodNumber;
+        yPt: z.ZodNumber;
+        widthPt: z.ZodNumber;
+        heightPt: z.ZodNumber;
+      }, z.core.$strip>;
+      fill: z.ZodOptional<z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+      }, z.core.$strip>>;
+      stroke: z.ZodOptional<z.ZodObject<{
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        widthPt: z.ZodNumber;
+      }, z.core.$strip>>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"ellipse">;
+      frame: z.ZodObject<{
+        xPt: z.ZodNumber;
+        yPt: z.ZodNumber;
+        widthPt: z.ZodNumber;
+        heightPt: z.ZodNumber;
+      }, z.core.$strip>;
+      fill: z.ZodOptional<z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+      }, z.core.$strip>>;
+      stroke: z.ZodOptional<z.ZodObject<{
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        widthPt: z.ZodNumber;
+      }, z.core.$strip>>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"line">;
+      from: z.ZodObject<{
+        xPt: z.ZodNumber;
+        yPt: z.ZodNumber;
+      }, z.core.$strip>;
+      to: z.ZodObject<{
+        xPt: z.ZodNumber;
+        yPt: z.ZodNumber;
+      }, z.core.$strip>;
+      stroke: z.ZodObject<{
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        widthPt: z.ZodNumber;
+      }, z.core.$strip>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"path">;
+      frame: z.ZodObject<{
+        xPt: z.ZodNumber;
+        yPt: z.ZodNumber;
+        widthPt: z.ZodNumber;
+        heightPt: z.ZodNumber;
+      }, z.core.$strip>;
+      subpaths: z.ZodArray<z.ZodObject<{
+        start: z.ZodObject<{
+          xPt: z.ZodNumber;
+          yPt: z.ZodNumber;
+        }, z.core.$strip>;
+        segments: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+          kind: z.ZodLiteral<"line">;
+          to: z.ZodObject<{
+            xPt: z.ZodNumber;
+            yPt: z.ZodNumber;
+          }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"cubic">;
+          control1: z.ZodObject<{
+            xPt: z.ZodNumber;
+            yPt: z.ZodNumber;
+          }, z.core.$strip>;
+          control2: z.ZodObject<{
+            xPt: z.ZodNumber;
+            yPt: z.ZodNumber;
+          }, z.core.$strip>;
+          to: z.ZodObject<{
+            xPt: z.ZodNumber;
+            yPt: z.ZodNumber;
+          }, z.core.$strip>;
+        }, z.core.$strip>], "kind">>;
+        closed: z.ZodBoolean;
+      }, z.core.$strip>>;
+      fill: z.ZodOptional<z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+      }, z.core.$strip>>;
+      fillRule: z.ZodOptional<z.ZodEnum<{
+        nonzero: "nonzero";
+        evenodd: "evenodd";
+      }>>;
+      stroke: z.ZodOptional<z.ZodObject<{
+        color: z.ZodObject<{
+          r: z.ZodNumber;
+          g: z.ZodNumber;
+          b: z.ZodNumber;
+        }, z.core.$strip>;
+        widthPt: z.ZodNumber;
+      }, z.core.$strip>>;
+      sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">>;
+  }, z.core.$strip>>;
+}, z.core.$strip>], "kind">;
+type ContentDocument = z.infer<typeof ContentDocumentSchema>;
+//#endregion
+//#region src/model/geometry.d.ts
+declare function flipY(box: Box$1, containerHeightPt: number): Box$1;
+//#endregion
+//#region src/model/bytes.d.ts
+declare const DocxBytesSchema: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+declare const PptxBytesSchema: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+declare const XlsxBytesSchema: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+declare const PdfBytesSchema: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+declare const OdtBytesSchema: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+declare const OdsBytesSchema: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+declare const OdpBytesSchema: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+declare const OdgBytesSchema: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+//#endregion
+//#region src/edit/docx/image.d.ts
+interface ImageInit$2 {
+  readonly format: 'png' | 'jpeg';
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly widthPt: number;
+  readonly heightPt: number;
+  readonly altText?: string;
+}
+interface MediaContext {
+  readonly pkg: Package$1;
+  readonly partPath: string;
+  readonly mediaDir: string;
+}
+//#endregion
+//#region src/edit/docx/run.d.ts
+interface RunInit$1 {
+  readonly text?: string;
+  readonly bold?: boolean;
+  readonly italic?: boolean;
+  readonly underline?: boolean;
+  readonly fontFamily?: string;
+  readonly sizePt?: number;
+  readonly color?: LayoutColor;
+}
+declare class DocxRun {
+  private readonly container;
+  private readonly node;
+  private removed;
+  constructor(container: XmlNode$1[], node: XmlElement$1);
+  private live;
+  private rPr;
+  get text(): string;
+  set text(value: string);
+  get bold(): boolean;
+  set bold(value: boolean);
+  get italic(): boolean;
+  set italic(value: boolean);
+  get underline(): boolean;
+  set underline(value: boolean);
+  get fontFamily(): string | undefined;
+  set fontFamily(value: string);
+  get sizePt(): number | undefined;
+  set sizePt(value: number);
+  get color(): LayoutColor | undefined;
+  set color(value: LayoutColor);
+  remove(): void;
+}
+//#endregion
+//#region src/edit/docx/paragraph.d.ts
+interface ParagraphInit$1 {
+  readonly text?: string;
+  readonly styleId?: string;
+  readonly alignment?: 'left' | 'center' | 'right' | 'justify';
+}
+interface ImageMediaContext {
+  readonly pkg: Package$1;
+  readonly documentRoot: XmlElement$1;
+  readonly media: MediaContext;
+}
+declare class DocxParagraph {
+  private readonly container;
+  private readonly node;
+  private readonly imageContext;
+  private removed;
+  constructor(container: XmlNode$1[], node: XmlElement$1, imageContext?: ImageMediaContext);
+  private live;
+  private pPr;
+  get text(): string;
+  runs(): DocxRun[];
+  appendRun(init?: RunInit$1): DocxRun;
+  appendTab(): void;
+  insertRunAt(index: number, init?: RunInit$1): DocxRun;
+  get styleId(): string | undefined;
+  set styleId(value: string | undefined);
+  get alignment(): 'left' | 'center' | 'right' | 'justify' | undefined;
+  set alignment(value: 'left' | 'center' | 'right' | 'justify' | undefined);
+  get list(): ContentListMembership$1 | undefined;
+  set list(value: ContentListMembership$1 | undefined);
+  insertImageAfter(image: ImageInit$2): void;
+  remove(): void;
+}
+//#endregion
+//#region src/edit/docx/table.d.ts
+interface TableInit$1 {
+  readonly rows: number;
+  readonly columns: number;
+  readonly columnWidthsTwips?: readonly number[];
+}
+declare class DocxTableCell {
+  private readonly node;
+  constructor(node: XmlElement$1);
+  paragraphs(): DocxParagraph[];
+  appendParagraph(init?: ParagraphInit$1): DocxParagraph;
+  get text(): string;
+}
+declare class DocxTableRow {
+  private readonly node;
+  constructor(node: XmlElement$1);
+  cells(): DocxTableCell[];
+}
+declare class DocxTable {
+  private readonly container;
+  private readonly node;
+  private removed;
+  constructor(container: XmlNode$1[], node: XmlElement$1);
+  private live;
+  rows(): DocxTableRow[];
+  cell(rowIndex: number, columnIndex: number): DocxTableCell;
+  appendRow(columnCount: number): DocxTableRow;
+  remove(): void;
+}
+//#endregion
+//#region src/edit/docx/editor.d.ts
+interface DocxBody {
+  insertParagraphAt(index: number, init?: ParagraphInit$1): DocxParagraph;
+  appendParagraph(init?: ParagraphInit$1): DocxParagraph;
+  appendTable(init: TableInit$1): DocxTable;
+  appendPageBreak(): void;
+}
+declare class DocxEditor {
+  readonly body: DocxBody;
+  private readonly pkg;
+  constructor(pkg: Package$1);
+  paragraphs(): DocxParagraph[];
+  tables(): DocxTable[];
+  toPackage(): Package$1;
+  toBytes(): Uint8Array<ArrayBuffer>;
+}
+declare function openDocx(bytes: Uint8Array<ArrayBuffer>): DocxEditor;
+declare function createDocx(): DocxEditor;
+//#endregion
+//#region src/edit/docx/content.d.ts
+declare function buildDocxPackage(content: ContentDocument): Package$1;
+//#endregion
+//#region src/edit/pptx/image.d.ts
+interface ImageInit$1 {
+  readonly format: 'png' | 'jpeg';
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly altText?: string;
+}
+//#endregion
+//#region src/edit/pptx/shape.d.ts
+declare class PptxShape {
+  private readonly container;
+  private readonly node;
+  private removed;
+  constructor(container: XmlNode$1[], node: XmlElement$1);
+  private live;
+  private spPrElement;
+  get frame(): Box | undefined;
+  set frame(value: Box);
+  get text(): string;
+  set text(value: string);
+  setParagraphs(paragraphs: readonly DrawingParagraphInit[]): void;
+  remove(): void;
+}
+interface DrawingRunInit {
+  readonly text: string;
+  readonly bold?: boolean;
+  readonly italic?: boolean;
+  readonly fontFamily?: string;
+  readonly sizePt?: number;
+  readonly color?: LayoutColor;
+}
+interface DrawingParagraphInit {
+  readonly runs: readonly DrawingRunInit[];
+  readonly alignment?: Alignment;
+}
+//#endregion
+//#region src/edit/pptx/slide.d.ts
+interface TextBoxInit$2 {
+  readonly frame: Box;
+  readonly text: string;
+}
+interface SlideImageInit$1 extends ImageInit$1 {
+  readonly frame: Box;
+}
+interface SlideContext$1 {
+  readonly pkg: Package$1;
+  readonly slidePartPath: string;
+  readonly mediaDir: string;
+}
+declare class PptxSlide {
+  private readonly container;
+  private readonly node;
+  private readonly context;
+  private removed;
+  constructor(container: XmlNode$1[], node: XmlElement$1, context: SlideContext$1);
+  private live;
+  shapes(): PptxShape[];
+  addTextBox(init: TextBoxInit$2): PptxShape;
+  addImage(init: SlideImageInit$1): PptxShape;
+  get notes(): string;
+  set notes(value: string);
+  remove(): void;
+}
+//#endregion
+//#region src/edit/pptx/editor.d.ts
+declare class PptxEditor {
+  private readonly pkg;
+  constructor(pkg: Package$1);
+  slides(): PptxSlide[];
+  addSlide(): PptxSlide;
+  removeSlideAt(index: number): void;
+  moveSlide(from: number, to: number): void;
+  get slideSize(): PageSize;
+  set slideSize(size: PageSize);
+  toPackage(): Package$1;
+  toBytes(): Uint8Array<ArrayBuffer>;
+}
+declare function openPptx(bytes: Uint8Array<ArrayBuffer>): PptxEditor;
+declare function createPptx(): PptxEditor;
+//#endregion
+//#region src/edit/pptx/content.d.ts
+declare function buildPptxPackage(content: ContentDocument): Package$1;
+//#endregion
+//#region src/edit/odt/run.d.ts
+interface RunInit {
+  readonly text?: string;
+  readonly bold?: boolean;
+  readonly italic?: boolean;
+  readonly underline?: boolean;
+  readonly fontFamily?: string;
+  readonly sizePt?: number;
+  readonly color?: LayoutColor;
+}
+declare class OdtRun {
+  private readonly container;
+  private readonly node;
+  private readonly pkg;
+  private removed;
+  constructor(container: XmlNode$2[], node: XmlElement$2, pkg: Package$2);
+  private live;
+  get text(): string;
+  set text(value: string);
+  get bold(): boolean;
+  set bold(value: boolean);
+  get italic(): boolean;
+  set italic(value: boolean);
+  get underline(): boolean;
+  set underline(value: boolean);
+  get fontFamily(): string | undefined;
+  set fontFamily(value: string);
+  get sizePt(): number | undefined;
+  set sizePt(value: number);
+  get color(): LayoutColor | undefined;
+  set color(value: LayoutColor);
+  remove(): void;
+}
+//#endregion
+//#region src/edit/odt/paragraph.d.ts
+interface ParagraphInit {
+  readonly text?: string;
+  readonly styleId?: string;
+  readonly alignment?: Alignment;
+}
+declare class OdtParagraph {
+  private readonly container;
+  private readonly node;
+  private readonly pkg;
+  private removed;
+  constructor(container: XmlNode$2[], node: XmlElement$2, pkg: Package$2);
+  private live;
+  get text(): string;
+  runs(): OdtRun[];
+  appendRun(init?: RunInit): OdtRun;
+  appendTab(): void;
+  insertRunAt(index: number, init?: RunInit): OdtRun;
+  get styleId(): string | undefined;
+  set styleId(value: string | undefined);
+  get alignment(): Alignment | undefined;
+  set alignment(value: Alignment | undefined);
+  remove(): void;
+}
+//#endregion
+//#region src/edit/odt/list.d.ts
+declare class OdtListItem {
+  private readonly node;
+  private readonly pkg;
+  constructor(node: XmlElement$2, pkg: Package$2);
+  appendParagraph(init?: ParagraphInit): OdtParagraph;
+  addNestedList(): OdtList;
+}
+declare class OdtList {
+  private readonly container;
+  private readonly node;
+  private readonly pkg;
+  private removed;
+  constructor(container: XmlNode$2[], node: XmlElement$2, pkg: Package$2);
+  private live;
+  items(): OdtListItem[];
+  addItem(): OdtListItem;
+  remove(): void;
+}
+//#endregion
+//#region src/edit/odt/table.d.ts
+interface TableInit {
+  readonly rows: number;
+  readonly columns: number;
+  readonly columnWidthsPt?: readonly number[];
+}
+declare class OdtTableCell {
+  private readonly node;
+  private readonly pkg;
+  constructor(node: XmlElement$2, pkg: Package$2);
+  paragraphs(): OdtParagraph[];
+  appendParagraph(init?: ParagraphInit): OdtParagraph;
+  get text(): string;
+}
+declare class OdtTableRow {
+  private readonly node;
+  private readonly pkg;
+  constructor(node: XmlElement$2, pkg: Package$2);
+  cells(): OdtTableCell[];
+}
+declare class OdtTable {
+  private readonly container;
+  private readonly node;
+  private readonly pkg;
+  private removed;
+  constructor(container: XmlNode$2[], node: XmlElement$2, pkg: Package$2);
+  private live;
+  rows(): OdtTableRow[];
+  cell(rowIndex: number, columnIndex: number): OdtTableCell;
+  appendRow(columnCount: number): OdtTableRow;
+  remove(): void;
+}
+//#endregion
+//#region src/edit/odt/editor.d.ts
+interface OdtBody {
+  appendParagraph(init?: ParagraphInit): OdtParagraph;
+  appendTable(init: TableInit): OdtTable;
+  appendList(): OdtList;
+  appendPageBreak(): void;
+}
+declare class OdtEditor {
+  readonly body: OdtBody;
+  private readonly pkg;
+  constructor(pkg: Package$2);
+  paragraphs(): OdtParagraph[];
+  tables(): OdtTable[];
+  lists(): OdtList[];
+  toPackage(): Package$2;
+  toBytes(): Uint8Array<ArrayBuffer>;
+}
+declare function openOdt(bytes: Uint8Array<ArrayBuffer>): OdtEditor;
+declare function createOdt(): OdtEditor;
+//#endregion
+//#region src/edit/odt/content.d.ts
+declare function buildOdtPackage(content: ContentDocument): Package$2;
+//#endregion
+//#region src/edit/odp/image.d.ts
+interface ImageInit {
+  readonly format: 'png' | 'jpeg';
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly altText?: string;
+}
+//#endregion
+//#region src/edit/odp/shape.d.ts
+declare class OdpShape {
+  private readonly container;
+  private readonly node;
+  private readonly pkg;
+  private removed;
+  constructor(container: XmlNode$2[], node: XmlElement$2, pkg: Package$2);
+  private live;
+  get name(): string | undefined;
+  get frame(): Box | undefined;
+  set frame(value: Box);
+  get rotationDeg(): number | undefined;
+  set rotationDeg(value: number | undefined);
+  private applyGeometry;
+  private textBox;
+  paragraphs(): OdtParagraph[];
+  appendParagraph(init?: ParagraphInit): OdtParagraph;
+  get text(): string;
+  set text(value: string);
+  addList(): OdtList;
+  remove(): void;
+}
+//#endregion
+//#region src/edit/odp/slide.d.ts
+interface TextBoxInit$1 {
+  readonly frame: Box;
+  readonly text: string;
+}
+interface SlideImageInit extends ImageInit {
+  readonly frame: Box;
+}
+interface SlideContext {
+  readonly pkg: Package$2;
+}
+declare class OdpSlide {
+  private readonly container;
+  private readonly node;
+  private readonly context;
+  private removed;
+  constructor(container: XmlNode$2[], node: XmlElement$2, context: SlideContext);
+  private live;
+  shapes(): OdpShape[];
+  addTextBox(init: TextBoxInit$1): OdpShape;
+  addImage(init: SlideImageInit): OdpShape;
+  get notes(): string;
+  set notes(value: string);
+  remove(): void;
+}
+//#endregion
+//#region src/edit/odp/editor.d.ts
+declare class OdpEditor {
+  private readonly pkg;
+  constructor(pkg: Package$2);
+  slides(): OdpSlide[];
+  addSlide(): OdpSlide;
+  removeSlideAt(index: number): void;
+  moveSlide(from: number, to: number): void;
+  get slideSize(): PageSize;
+  set slideSize(size: PageSize);
+  toPackage(): Package$2;
+  toBytes(): Uint8Array<ArrayBuffer>;
+}
+declare function openOdp(bytes: Uint8Array<ArrayBuffer>): OdpEditor;
+declare function createOdp(): OdpEditor;
+//#endregion
+//#region src/edit/odp/content.d.ts
+declare function buildOdpPackage(content: ContentDocument): Package$2;
+//#endregion
+//#region src/edit/ods/cell.d.ts
+declare class OdsCell {
+  private readonly node;
+  private readonly pkg;
+  constructor(node: XmlElement$2, pkg: Package$2);
+  get value(): ContentCellValue$1;
+  set value(value: ContentCellValue$1);
+  get formula(): string | undefined;
+  set formula(value: string | undefined);
+  get displayText(): string;
+  set displayText(value: string);
+  setStyledRuns(runs: readonly ContentRun$1[]): void;
+}
+//#endregion
+//#region src/edit/ods/sheet.d.ts
+declare class OdsSheet {
+  private readonly container;
+  private readonly node;
+  private readonly pkg;
+  private removed;
+  constructor(container: XmlNode$2[], node: XmlElement$2, pkg: Package$2);
+  private live;
+  get name(): string;
+  set name(value: string);
+  get printSettings(): ContentSheetPrintSettings$1;
+  set printSettings(value: ContentSheetPrintSettings$1);
+  cell(row: number, column: number): OdsCell;
+  cellAt(reference: string): OdsCell;
+  mergeCells(startRow: number, startColumn: number, rowSpan: number, colSpan: number): OdsCell;
+  remove(): void;
+}
+//#endregion
+//#region src/edit/ods/editor.d.ts
+declare class OdsEditor {
+  private readonly pkg;
+  constructor(pkg: Package$2);
+  sheets(): OdsSheet[];
+  sheet(name: string): OdsSheet;
+  addSheet(name: string): OdsSheet;
+  removeSheetAt(index: number): void;
+  toPackage(): Package$2;
+  toBytes(): Uint8Array<ArrayBuffer>;
+}
+declare function openOds(bytes: Uint8Array<ArrayBuffer>): OdsEditor;
+declare function createOds(): OdsEditor;
+//#endregion
+//#region src/edit/ods/content.d.ts
+declare function buildOdsPackage(content: ContentDocument): Package$2;
+//#endregion
+//#region src/edit/odg/vector.d.ts
+interface BoxVectorInit {
+  readonly frame: Box$1;
+  readonly fill?: Color;
+  readonly stroke?: ContentStroke$1;
+}
+type OdgBoxVectorKind = 'rect' | 'ellipse';
+declare class OdgBoxVector {
+  private readonly container;
+  private readonly node;
+  private readonly pkg;
+  private removed;
+  constructor(container: XmlNode$2[], node: XmlElement$2, pkg: Package$2);
+  private live;
+  get kind(): OdgBoxVectorKind;
+  get name(): string | undefined;
+  get frame(): Box$1 | undefined;
+  set frame(value: Box$1);
+  get fill(): Color | undefined;
+  set fill(value: Color | undefined);
+  get stroke(): ContentStroke$1 | undefined;
+  set stroke(value: ContentStroke$1 | undefined);
+  remove(): void;
+}
+interface LineVectorInit {
+  readonly from: ContentPathPoint$1;
+  readonly to: ContentPathPoint$1;
+  readonly stroke: ContentStroke$1;
+}
+declare class OdgLineVector {
+  private readonly container;
+  private readonly node;
+  private readonly pkg;
+  private removed;
+  constructor(container: XmlNode$2[], node: XmlElement$2, pkg: Package$2);
+  private live;
+  get name(): string | undefined;
+  get from(): ContentPathPoint$1 | undefined;
+  set from(value: ContentPathPoint$1);
+  get to(): ContentPathPoint$1 | undefined;
+  set to(value: ContentPathPoint$1);
+  get stroke(): ContentStroke$1 | undefined;
+  set stroke(value: ContentStroke$1);
+  remove(): void;
+}
+interface PathVectorInit {
+  readonly frame: Box$1;
+  readonly subpaths: readonly ContentSubpath$1[];
+  readonly fill?: Color;
+  readonly stroke?: ContentStroke$1;
+}
+declare class OdgPathVector {
+  private readonly container;
+  private readonly node;
+  private readonly pkg;
+  private removed;
+  constructor(container: XmlNode$2[], node: XmlElement$2, pkg: Package$2);
+  private live;
+  get name(): string | undefined;
+  get frame(): Box$1 | undefined;
+  set frame(value: Box$1);
+  get fill(): Color | undefined;
+  set fill(value: Color | undefined);
+  get stroke(): ContentStroke$1 | undefined;
+  set stroke(value: ContentStroke$1 | undefined);
+  get subpaths(): ContentSubpath$1[];
+  remove(): void;
+}
+//#endregion
+//#region src/edit/odg/page.d.ts
+interface TextBoxInit {
+  readonly frame: Box$1;
+  readonly text: string;
+}
+interface PageImageInit extends ImageInit {
+  readonly frame: Box$1;
+}
+interface PageContext {
+  readonly pkg: Package$2;
+}
+declare class OdgPage {
+  private readonly container;
+  private readonly node;
+  private readonly context;
+  private removed;
+  constructor(container: XmlNode$2[], node: XmlElement$2, context: PageContext);
+  private live;
+  shapes(): OdpShape[];
+  addTextBox(init: TextBoxInit): OdpShape;
+  addImage(init: PageImageInit): OdpShape;
+  addRect(init: BoxVectorInit): OdgBoxVector;
+  addEllipse(init: BoxVectorInit): OdgBoxVector;
+  addLine(init: LineVectorInit): OdgLineVector;
+  addPath(init: PathVectorInit): OdgPathVector;
+  remove(): void;
+}
+//#endregion
+//#region src/edit/odg/editor.d.ts
+declare class OdgEditor {
+  private readonly pkg;
+  constructor(pkg: Package$2);
+  pages(): OdgPage[];
+  addPage(): OdgPage;
+  removePageAt(index: number): void;
+  get pageSize(): PageSize;
+  set pageSize(size: PageSize);
+  toPackage(): Package$2;
+  toBytes(): Uint8Array<ArrayBuffer>;
+}
+declare function openOdg(bytes: Uint8Array<ArrayBuffer>): OdgEditor;
+declare function createOdg(): OdgEditor;
+//#endregion
+//#region src/edit/odg/content.d.ts
+declare function buildOdgPackage(content: ContentDocument): Package$2;
+//#endregion
+//#region src/mathml/layout-types.d.ts
+interface MathColor {
+  readonly r: number;
+  readonly g: number;
+  readonly b: number;
+}
+interface MathGlyphRun {
+  readonly kind: 'glyphs';
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly text: string;
+  readonly sizePt: number;
+  readonly color: MathColor;
+}
+interface MathRule {
+  readonly kind: 'rule';
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly widthPt: number;
+  readonly heightPt: number;
+  readonly color: MathColor;
+}
+interface MathStroke {
+  readonly kind: 'stroke';
+  readonly points: readonly {
+    readonly xPt: number;
+    readonly yPt: number;
+  }[];
+  readonly widthPt: number;
+  readonly color: MathColor;
+}
+type MathLayoutItem = MathGlyphRun | MathRule | MathStroke;
+interface MathBox {
+  readonly widthPt: number;
+  readonly heightPt: number;
+  readonly ascentPt: number;
+  readonly descentPt: number;
+  readonly items: readonly MathLayoutItem[];
+}
+type MathDiagnosticKind = 'unsupported-element' | 'missing-glyph';
+interface MathDiagnostic {
+  readonly kind: MathDiagnosticKind;
+  readonly detail: string;
+}
+interface MathLayoutResult {
+  readonly box: MathBox;
+  readonly diagnostics: readonly MathDiagnostic[];
+}
+//#endregion
+//#region src/mathml/metrics.d.ts
+interface MathGlyphMetrics {
+  readonly advanceWidthPt: number;
+  readonly italicCorrectionPt: number;
+  readonly topAccentXPt?: number;
+}
+interface MathFontMetrics {
+  readonly ascentPerEm: number;
+  readonly descentPerEm: number;
+  readonly axisHeightPt: number;
+  readonly fractionRuleThicknessPt: number;
+  readonly fractionNumeratorShiftUpPt: number;
+  readonly fractionNumeratorDisplayShiftUpPt: number;
+  readonly fractionDenominatorShiftDownPt: number;
+  readonly fractionDenominatorDisplayShiftDownPt: number;
+  readonly fractionNumeratorGapMinPt: number;
+  readonly fractionDenominatorGapMinPt: number;
+  readonly radicalRuleThicknessPt: number;
+  readonly radicalExtraAscenderPt: number;
+  readonly radicalVerticalGapPt: number;
+  readonly radicalKernBeforeDegreePt: number;
+  readonly radicalKernAfterDegreePt: number;
+  readonly radicalDegreeBottomRaisePercent: number;
+  readonly subscriptShiftDownPt: number;
+  readonly superscriptShiftUpPt: number;
+  readonly superscriptShiftUpCrampedPt: number;
+  readonly subSuperscriptGapMinPt: number;
+  readonly superscriptBaselineDropMaxPt: number;
+  readonly subscriptBaselineDropMinPt: number;
+  readonly spaceAfterScriptPt: number;
+  readonly upperLimitGapMinPt: number;
+  readonly upperLimitBaselineRiseMinPt: number;
+  readonly lowerLimitGapMinPt: number;
+  readonly lowerLimitBaselineDropMinPt: number;
+  readonly stackTopShiftUpPt: number;
+  readonly stackBottomShiftDownPt: number;
+  readonly stackGapMinPt: number;
+  readonly scriptPercentScaleDown: number;
+  readonly scriptScriptPercentScaleDown: number;
+  readonly defaultRuleThicknessPt: number;
+  glyph(codePoint: number, sizePt: number): MathGlyphMetrics | undefined;
+}
+//#endregion
+//#region src/mathml/nodes.d.ts
+interface MathMlAttribute {
+  readonly name: string;
+  readonly value: string;
+}
+interface MathMlElement {
+  readonly type: 'element';
+  readonly tag: string;
+  readonly attributes: readonly MathMlAttribute[];
+  readonly children: readonly MathMlNode[];
+}
+interface MathMlText {
+  readonly type: 'text';
+  readonly value: string;
+}
+type MathMlNode = MathMlElement | MathMlText | {
+  readonly type: 'cdata' | 'comment' | 'declaration' | 'pi';
+};
+declare function isMathMlElement(node: MathMlNode): node is MathMlElement;
+declare function localName(tag: string): string;
+declare function elementLocalName(element: MathMlElement): string;
+declare function elementChildren(node: MathMlElement): readonly MathMlElement[];
+declare function firstChildByLocalName(node: MathMlElement, name: string): MathMlElement | undefined;
+declare function textContent(node: MathMlNode): string;
+//#endregion
+//#region src/mathml/variant.d.ts
+type MathVariant = 'normal' | 'bold' | 'italic' | 'bold-italic' | 'double-struck' | 'bold-fraktur' | 'script' | 'bold-script' | 'fraktur' | 'sans-serif' | 'bold-sans-serif' | 'sans-serif-italic' | 'sans-serif-bold-italic' | 'monospace';
+declare function mapMathVariant(codePoint: number, variant: MathVariant): number;
+declare function applyMathVariant(text: string, variant: MathVariant): string;
+declare function isMathVariant(value: string): value is MathVariant;
+//#endregion
+//#region src/mathml/layout.d.ts
+interface LayoutFormulaOptions {
+  readonly metrics: MathFontMetrics;
+  readonly sizePt: number;
+  readonly color: MathColor;
+}
+declare function layoutFormula(mathml: readonly MathMlNode[], options: LayoutFormulaOptions): MathLayoutResult;
+//#endregion
+//#region src/mathml/operators.d.ts
+interface OperatorProperties {
+  readonly lspaceEm: number;
+  readonly rspaceEm: number;
+  readonly stretchy: boolean;
+  readonly largeop: boolean;
+  readonly movablelimits: boolean;
+  readonly fence: boolean;
+  readonly separator: boolean;
+}
+declare function operatorProperties(text: string): OperatorProperties;
+//#endregion
+//#region src/ooxml/docx/read.d.ts
+declare function readDocxContent(pkg: Package$1): ContentDocument;
+//#endregion
+//#region src/ooxml/pptx/read.d.ts
+declare function readPptxContent(pkg: Package$1): ContentDocument;
+//#endregion
+//#region src/model/formula.d.ts
+interface EmbeddedFormula {
+  readonly mathml: readonly MathMlNode[];
+  readonly starMath: string | undefined;
+}
+//#endregion
+//#region src/odf/odt/read.d.ts
+interface OdtContentResult {
+  readonly document: ContentDocument;
+  readonly formulas: ReadonlyMap<string, EmbeddedFormula>;
+}
+declare function readOdtContent(pkg: Package$2): OdtContentResult;
+//#endregion
+//#region src/odf/odp/read.d.ts
+interface OdpContentResult {
+  readonly document: ContentDocument;
+  readonly formulas: ReadonlyMap<string, EmbeddedFormula>;
+}
+declare function readOdpContent(pkg: Package$2): OdpContentResult;
+//#endregion
+//#region src/odf/ods/read.d.ts
+declare function readOdsContent(pkg: Package$2): ContentDocument;
+//#endregion
+//#region src/odf/odg/read.d.ts
+declare function readOdgContent(pkg: Package$2): ContentDocument;
+//#endregion
+//#region src/odf/formula/read.d.ts
+interface StandaloneFormulaContent extends EmbeddedFormula {
+  readonly metadata: LayoutMetadata$1;
+}
+declare function readOdfFormulaContent(pkg: Package$2): StandaloneFormulaContent;
+declare function readOdfEmbeddedFormula(outerPkg: Package$2, subPackagePath: string): EmbeddedFormula | undefined;
+//#endregion
+//#region src/layout/engine.d.ts
+interface EngineLayoutOptions {
+  readonly measurer: TextMeasurer;
+  readonly formulas?: ReadonlyMap<string, EmbeddedFormula>;
+}
+interface WordprocessingLayoutResult {
+  readonly document: LayoutDocument$1;
+  readonly formulas: readonly PositionedFormula$1[];
+}
+type WordprocessingContentDocument = Extract<ContentDocument, {
+  kind: 'wordprocessing';
+}>;
+declare function convertWordprocessingToLayout(doc: WordprocessingContentDocument, options: EngineLayoutOptions): WordprocessingLayoutResult;
+//#endregion
+//#region src/layout/slides.d.ts
+interface SlidesLayoutOptions {
+  readonly measurer: TextMeasurer;
+  readonly formulas?: ReadonlyMap<string, EmbeddedFormula>;
+}
+interface PresentationLayoutResult {
+  readonly document: LayoutDocument$1;
+  readonly formulas: readonly PositionedFormula$1[];
+}
+type PresentationContentDocument = Extract<ContentDocument, {
+  kind: 'presentation';
+}>;
+declare function convertPresentationToLayout(doc: PresentationContentDocument, options: SlidesLayoutOptions): PresentationLayoutResult;
+//#endregion
+//#region src/layout/sheets.d.ts
+interface SheetsLayoutOptions {
+  readonly measurer: TextMeasurer;
+  readonly signal?: AbortSignal;
+}
+type SpreadsheetContentDocument = Extract<ContentDocument, {
+  kind: 'spreadsheet';
+}>;
+declare function convertSpreadsheetToLayout(doc: SpreadsheetContentDocument, options: SheetsLayoutOptions): LayoutDocument$1;
+//#endregion
+//#region src/layout/drawing.d.ts
+interface DrawingLayoutOptions {
+  readonly measurer: TextMeasurer;
+}
+type DrawingContentDocument = Extract<ContentDocument, {
+  kind: 'drawing';
+}>;
+declare function convertDrawingToLayout(doc: DrawingContentDocument, options: DrawingLayoutOptions): LayoutDocument$1;
+//#endregion
+//#region src/layout/reconstruct.d.ts
+interface ReconstructOptions {
+  readonly signal?: AbortSignal;
+}
+declare function reconstructWordprocessing(doc: LayoutDocument$1, options?: ReconstructOptions): ContentDocument;
+declare function reconstructPresentation(doc: LayoutDocument$1, options?: ReconstructOptions): ContentDocument;
+declare function reconstructDrawing(doc: LayoutDocument$1, options?: ReconstructOptions): ContentDocument;
+declare function reconstructSpreadsheet(doc: LayoutDocument$1, options?: ReconstructOptions): ContentDocument;
+//#endregion
+//#region src/convert/convert.d.ts
+interface DocumentToPdfOptions {
+  readonly signal?: AbortSignal;
+  readonly onSubstitution?: (substitution: WinAnsiSubstitution$1, context: {
+    readonly pageIndex: number;
+  }) => void;
+  readonly onDocument?: (pkg: DocumentPackage) => void;
+}
+declare function docxToPdf(bytes: Uint8Array<ArrayBuffer>, options?: DocumentToPdfOptions): Uint8Array<ArrayBuffer>;
+declare function odtToPdf(bytes: Uint8Array<ArrayBuffer>, options?: DocumentToPdfOptions): Uint8Array<ArrayBuffer>;
+declare function pptxToPdf(bytes: Uint8Array<ArrayBuffer>, options?: DocumentToPdfOptions): Uint8Array<ArrayBuffer>;
+declare function odpToPdf(bytes: Uint8Array<ArrayBuffer>, options?: DocumentToPdfOptions): Uint8Array<ArrayBuffer>;
+declare function odsToPdf(bytes: Uint8Array<ArrayBuffer>, options?: DocumentToPdfOptions): Uint8Array<ArrayBuffer>;
+declare function odgToPdf(bytes: Uint8Array<ArrayBuffer>, options?: DocumentToPdfOptions): Uint8Array<ArrayBuffer>;
+declare function odfToPdf(bytes: Uint8Array<ArrayBuffer>, options?: DocumentToPdfOptions): Uint8Array<ArrayBuffer>;
+interface PdfToDocumentOptions {
+  readonly signal?: AbortSignal;
+  readonly sink?: PdfDiagnosticSink$1;
+  readonly onDocument?: (pkg: DocumentPackage) => void;
+}
+declare function pdfToDocx(bytes: Uint8Array<ArrayBuffer>, options?: PdfToDocumentOptions): Uint8Array<ArrayBuffer>;
+declare function pdfToPptx(bytes: Uint8Array<ArrayBuffer>, options?: PdfToDocumentOptions): Uint8Array<ArrayBuffer>;
+declare function pdfToOdt(bytes: Uint8Array<ArrayBuffer>, options?: PdfToDocumentOptions): Uint8Array<ArrayBuffer>;
+declare function pdfToOdp(bytes: Uint8Array<ArrayBuffer>, options?: PdfToDocumentOptions): Uint8Array<ArrayBuffer>;
+declare function pdfToOdg(bytes: Uint8Array<ArrayBuffer>, options?: PdfToDocumentOptions): Uint8Array<ArrayBuffer>;
+declare function pdfToOds(bytes: Uint8Array<ArrayBuffer>, options?: PdfToDocumentOptions): Uint8Array<ArrayBuffer>;
+interface DocumentBridgeOptions {
+  readonly signal?: AbortSignal;
+  readonly onDocument?: (pkg: DocumentPackage) => void;
+}
+declare function odtToDocx(bytes: Uint8Array<ArrayBuffer>, options?: DocumentBridgeOptions): Uint8Array<ArrayBuffer>;
+declare function docxToOdt(bytes: Uint8Array<ArrayBuffer>, options?: DocumentBridgeOptions): Uint8Array<ArrayBuffer>;
+declare function odpToPptx(bytes: Uint8Array<ArrayBuffer>, options?: DocumentBridgeOptions): Uint8Array<ArrayBuffer>;
+declare function pptxToOdp(bytes: Uint8Array<ArrayBuffer>, options?: DocumentBridgeOptions): Uint8Array<ArrayBuffer>;
+declare function odsToXlsx(bytes: Uint8Array<ArrayBuffer>, options?: DocumentBridgeOptions): Uint8Array<ArrayBuffer>;
+declare function xlsxToOds(bytes: Uint8Array<ArrayBuffer>, options?: DocumentBridgeOptions): Uint8Array<ArrayBuffer>;
+interface OdmToPdfOptions extends DocumentToPdfOptions {
+  readonly resolveSubDocument?: (href: string) => Uint8Array<ArrayBuffer> | undefined;
+}
+declare class OdmUnresolvedSectionError extends Error {
+  readonly hrefs: readonly string[];
+  constructor(hrefs: readonly string[]);
+}
+declare function odmToPdf(bytes: Uint8Array<ArrayBuffer>, options?: OdmToPdfOptions): Uint8Array<ArrayBuffer>;
+declare function odbToXlsx(bytes: Uint8Array<ArrayBuffer>, options?: DocumentBridgeOptions): Uint8Array<ArrayBuffer>;
+interface OdbToCsvOptions extends DocumentBridgeOptions {
+  readonly table?: string;
+}
+declare function odbToCsv(bytes: Uint8Array<ArrayBuffer>, options?: OdbToCsvOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/convert/codec.d.ts
+declare const docxPdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+declare const pptxPdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+declare const odtPdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+declare const odpPdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+declare const odsPdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+declare const odgPdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+declare const odtDocxCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+declare const odpPptxCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+declare const odsXlsxCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+//#endregion
+//#region src/hsqldb/script.d.ts
+declare class HsqldbScriptParseError extends Error {
+  readonly statement: string;
+  constructor(message: string, statement: string);
+}
+interface HsqldbColumn {
+  readonly name: string;
+  readonly type: string;
+}
+interface HsqldbTable {
+  readonly tableName: string;
+  readonly columns: readonly HsqldbColumn[];
+  readonly rows: readonly (readonly ContentCellValue$1[])[];
+}
+declare function displayTextFor(value: ContentCellValue$1): string;
+declare function parseHsqldbScript(bytes: Uint8Array): HsqldbTable[];
+//#endregion
+//#region src/hsqldb/cache.d.ts
+declare function decodeHsqldbCachedTables(tables: readonly HsqldbTable[], scriptText: string, dataBytes: Uint8Array<ArrayBuffer>, propertiesText: string): readonly HsqldbTable[];
+//#endregion
+//#region src/hsqldb/rowformat.d.ts
+declare class HsqldbRowFormatError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/odb/read.d.ts
+declare class OdbNoEmbeddedDataSourceError extends Error {
+  readonly url: string | undefined;
+  constructor(url: string | undefined);
+}
+type OdbUnsupportedFormat = 'hsqldb-binary' | 'hsqldb-compressed' | 'unrecognised-engine';
+declare class OdbUnsupportedFormatError extends Error {
+  readonly format: OdbUnsupportedFormat;
+  constructor(format: OdbUnsupportedFormat, detail: string);
+}
+declare function readOdbTables(pkg: Package$2): readonly HsqldbTable[];
+//#endregion
+//#region src/odb/spreadsheet.d.ts
+declare function odbTablesToSpreadsheetDocument(tables: readonly HsqldbTable[]): ContentDocument;
+//#endregion
+//#region src/odb/csv.d.ts
+declare class OdbTableNotSpecifiedError extends Error {
+  readonly availableTables: readonly string[];
+  constructor(availableTables: readonly string[]);
+}
+declare class OdbTableNotFoundError extends Error {
+  readonly table: string;
+  readonly availableTables: readonly string[];
+  constructor(table: string, availableTables: readonly string[]);
+}
+//#endregion
+//#region src/firebird/reader.d.ts
+declare class FirebirdBackupParseError extends Error {
+  readonly offset: number;
+  constructor(message: string, offset: number);
+}
+//#endregion
+//#region src/firebird/blr-types.d.ts
+declare class FirebirdUnsupportedFieldTypeError extends Error {
+  readonly blrType: number;
+  constructor(blrType: number);
+}
+//#endregion
+//#region src/firebird/schema.d.ts
+declare class FirebirdSchemaParseError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/firebird/data.d.ts
+declare class FirebirdDataParseError extends Error {
+  constructor(message: string);
+}
+declare class FirebirdCompositeRecordUnsupportedError extends Error {
+  readonly recordType: number;
+  constructor(recordType: number, context: string);
+}
+//#endregion
+//#region src/firebird/backup.d.ts
+declare class FirebirdBackupFormatError extends Error {
+  constructor(message: string);
+}
+interface FirebirdBackupSummary {
+  readonly backupFormatVersion: number;
+  readonly transportable: boolean;
+  readonly compressed: boolean;
+  readonly pageSizeBytes: number | undefined;
+}
+declare const SUPPORTED_BACKUP_FORMAT_VERSION = 10;
+interface ReadFirebirdBackupResult {
+  readonly summary: FirebirdBackupSummary;
+  readonly tables: readonly HsqldbTable[];
+}
+declare function readFirebirdBackup(bytes: Uint8Array<ArrayBuffer>): ReadFirebirdBackupResult;
+//#endregion
+//#region src/convert/port.d.ts
+type DocumentFormat = 'docx' | 'pptx' | 'xlsx' | 'odt' | 'odp' | 'ods' | 'odg' | 'odf' | 'pdf';
+interface DocumentPayload {
+  readonly format: DocumentFormat;
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+interface Diagnostic {
+  readonly severity: 'info' | 'warning';
+  readonly code: string;
+  readonly message: string;
+  readonly pageIndex?: number;
+}
+interface ConversionRequest {
+  readonly source: DocumentPayload;
+  readonly targetFormat: DocumentFormat;
+}
+interface ConversionResult {
+  readonly document: DocumentPayload;
+  readonly diagnostics: readonly Diagnostic[];
+  readonly package?: DocumentPackage;
+}
+interface DocumentConverter {
+  readonly contractVersion: number;
+  readonly conversions: readonly {
+    readonly source: DocumentFormat;
+    readonly target: DocumentFormat;
+  }[];
+  convert(request: ConversionRequest, options: {
+    readonly signal: AbortSignal;
+  }): Promise<ConversionResult>;
+}
+//#endregion
+//#region src/convert/local.d.ts
+declare function createLocalDocumentConverter(): DocumentConverter;
+//#endregion
+//#region src/ports/clock.d.ts
+interface ClockPort {
+  now(): Date;
+}
+declare const systemClock: ClockPort;
+declare function fixedClock(date: Date): ClockPort;
+//#endregion
+//#region src/ports/abort.d.ts
+declare function throwIfAborted(signal: AbortSignal | undefined): void;
+//#endregion
+export { type Alignment, type Attribute, AttributeSchema, type BinaryPart, BinaryPartSchema, type Box, COLOR_BLACK, CONTENT_FORMAT_VERSION, type ClockPort, type Comment, CommentSchema, type CompactAttrPairs, type CompactPackage, CompactPackageSchema, type CompactPart, CompactPartSchema, type CompactXmlNode, CompactXmlNodeSchema, type ContentBlock, ContentBlockSchema, type ContentCellValue, ContentCellValueSchema, type ContentDocument, ContentDocumentSchema, type ContentDrawPage, ContentDrawPageSchema, type ContentImageBlock, ContentImageBlockSchema, type ContentListMembership, type ContentPageBreak, ContentPageBreakSchema, type ContentParagraph, ContentParagraphSchema, type ContentPathPoint, ContentPathPointSchema, type ContentPathSegment, ContentPathSegmentSchema, type ContentRun, ContentRunSchema, type ContentSection, ContentSectionSchema, type ContentShape, ContentShapeSchema, type ContentSheet, type ContentSheetCell, ContentSheetCellSchema, type ContentSheetColumn, ContentSheetColumnSchema, type ContentSheetImage, type ContentSheetPrintRange, ContentSheetPrintRangeSchema, type ContentSheetPrintSettings, ContentSheetPrintSettingsSchema, type ContentSheetRepeatRange, ContentSheetRepeatRangeSchema, type ContentSheetRow, ContentSheetRowSchema, ContentSheetSchema, type ContentSlide, ContentSlideSchema, type ContentStroke, ContentStrokeSchema, type ContentSubpath, ContentSubpathSchema, type ContentTable, type ContentTableCell, ContentTableCellSchema, type ContentTableRow, ContentTableRowSchema, ContentTableSchema, type ContentVector, ContentVectorSchema, type ConversionRequest, type ConversionResult, DEFAULT_LAYOUT_FONT, type DefinedName, DefinedNameSchema, type Diagnostic, type DocumentBridgeOptions, type DocumentConverter, type DocumentFormat, type DocumentPayload, type DocumentToPdfOptions, type DocxBody, DocxBytesSchema, DocxEditor, DocxParagraph, DocxRun, DocxTable, DocxTableCell, DocxTableRow, type DrawingLayoutOptions, type DrawingParagraphInit, type DrawingRunInit, type EmbeddedFormula, type EngineLayoutOptions, SUPPORTED_BACKUP_FORMAT_VERSION as FIREBIRD_SUPPORTED_BACKUP_FORMAT_VERSION, FirebirdBackupFormatError, FirebirdBackupParseError, type FirebirdBackupSummary, FirebirdCompositeRecordUnsupportedError, FirebirdDataParseError, FirebirdSchemaParseError, FirebirdUnsupportedFieldTypeError, type HsqldbColumn, HsqldbRowFormatError, HsqldbScriptParseError, type HsqldbTable, LAYOUT_FORMAT_VERSION, type LayoutColor, type LayoutDocument, type LayoutEllipse, type LayoutFont, type LayoutFormulaOptions, type LayoutImage, type LayoutImageAsset, type LayoutItem, type LayoutLine, type LayoutLink, type LayoutMetadata, type LayoutPage, type LayoutPath, type LayoutPathSegment, type LayoutRect, type LayoutSubpath, type LayoutText, type LoadedMathFont, type Margins, type MathBox, type MathColor, type MathDiagnostic, type MathDiagnosticKind, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphMetrics, type MathGlyphRun, type MathLayoutItem, type MathLayoutResult, type MathMlAttribute, type MathMlElement, type MathMlNode, type MathMlText, type MathRule, type MathStroke, type MathVariant, NOOP_DIAGNOSTIC_SINK, OdbNoEmbeddedDataSourceError, OdbTableNotFoundError, OdbTableNotSpecifiedError, type OdbToCsvOptions, type OdbUnsupportedFormat, OdbUnsupportedFormatError, OdgBoxVector, type BoxVectorInit as OdgBoxVectorInit, OdgBytesSchema, OdgEditor, OdgLineVector, type LineVectorInit as OdgLineVectorInit, OdgPage, type PageImageInit as OdgPageImageInit, OdgPathVector, type PathVectorInit as OdgPathVectorInit, type TextBoxInit as OdgTextBoxInit, type OdmToPdfOptions, OdmUnresolvedSectionError, OdpBytesSchema, type OdpContentResult, OdpEditor, OdpShape, OdpSlide, type SlideImageInit as OdpSlideImageInit, type TextBoxInit$1 as OdpTextBoxInit, OdsBytesSchema, OdsCell, OdsEditor, OdsSheet, type OdtBody, OdtBytesSchema, type OdtContentResult, OdtEditor, OdtList, OdtListItem, OdtParagraph, type ParagraphInit as OdtParagraphInit, OdtRun, type RunInit as OdtRunInit, OdtTable, OdtTableCell, type TableInit as OdtTableInit, OdtTableRow, type OperatorProperties, PAGE_SIZE_A4, PAGE_SIZE_LETTER, type Package, PackageSchema, type PageSize, type Part, PartSchema, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfParseError, type PdfToDocumentOptions, type PositionedFormula, PptxBytesSchema, PptxEditor, PptxShape, PptxSlide, type PresentationLayoutResult, type ReadFirebirdBackupResult, type ReadPdfOptions, type ReconstructOptions, type Relationship, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN, type SheetsLayoutOptions, type SlideImageInit$1 as SlideImageInit, type SlidesLayoutOptions, type StandaloneFormulaContent, type TextBoxInit$2 as TextBoxInit, type WinAnsiSubstitution, type WordprocessingLayoutResult, type WritePdfOptions, XlsxBytesSchema, type XmlCdata, XmlCdataSchema, type XmlComment, XmlCommentSchema, type XmlDeclaration, XmlDeclarationSchema, type XmlElement, XmlElementSchema, type XmlNode, XmlNodeSchema, type XmlPart, XmlPartSchema, type XmlPi, XmlPiSchema, type XmlText, XmlTextSchema, applyMathVariant, attr, base64ToBytes, buildDocxPackage, buildOdgPackage, buildOdpPackage, buildOdsPackage, buildOdtPackage, buildPptxPackage, buildXml, bytesToBase64, childrenWithTag, compactCodec, compactPackageCodec, convertDrawingToLayout, convertPresentationToLayout, convertSpreadsheetToLayout, convertWordprocessingToLayout, createDocx, createLocalDocumentConverter, createOdg, createOdp, createOds, createOdt, createPptx, decodeCompactPackage, decodeEntities, decodeHsqldbCachedTables, decodePackage, docxPdfCodec, docxToOdt, docxToPdf, elementChildren, elementLocalName, elementsWithTag, encodeCompactPackage, encodePackage, firstChildByLocalName, fixedClock, flipY, fromCompact, displayTextFor as hsqldbCellDisplayText, isCompactXmlNode, isContentBlock, isMathMlElement, isMathVariant, isXmlNode, layoutFormula, loadMathFont, localName, mapMathVariant, textContent as mathMlTextContent, odbTablesToSpreadsheetDocument, odbToCsv, odbToXlsx, odfToPdf, odgPdfCodec, odgToPdf, odmToPdf, odpPdfCodec, odpPptxCodec, odpToPdf, odpToPptx, odsPdfCodec, odsToPdf, odsToXlsx, odsXlsxCodec, odtDocxCodec, odtPdfCodec, odtToDocx, odtToPdf, openDocx, openOdg, openOdp, openOds, openOdt, openPptx, operatorProperties, packageCodec, parseHsqldbScript, parsePackage, parseXml, pdfCodec, pdfToDocx, pdfToOdg, pdfToOdp, pdfToOds, pdfToOdt, pdfToPptx, pptxPdfCodec, pptxToOdp, pptxToPdf, readDocxContent, readFirebirdBackup, readOdbTables, readOdfEmbeddedFormula, readOdfFormulaContent, readOdgContent, readOdpContent, readOdsContent, readOdtContent, readPdf, readPptxContent, reconstructDrawing, reconstructPresentation, reconstructSpreadsheet, reconstructWordprocessing, resolveRelationships, rgbHexToColor, rootElement, serializePackage, systemClock, textContent$1 as textContent, throwIfAborted, toCompact, unzipPackage, walk, writePdf, xlsxToOds, xmlCodec, zipPackage };