docx-plus 0.0.0 → 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,3230 @@
+import { Element } from "xml-js";
+//#region src/file/file-child.d.ts
+declare class FileChild extends XmlComponent {
+  readonly fileChild: symbol;
+}
+//#endregion
+//#region src/util/values.d.ts
+type UniversalMeasure = `${"-" | ""}${number}${"mm" | "cm" | "in" | "pt" | "pc" | "pi"}`;
+type PositiveUniversalMeasure = `${number}${"mm" | "cm" | "in" | "pt" | "pc" | "pi"}`;
+type Percentage = `${"-" | ""}${number}%`;
+type PositivePercentage = `${number}%`;
+type RelativeMeasure = `${"-" | ""}${number}${"em" | "ex"}`;
+declare const decimalNumber: (val: number) => number;
+declare const unsignedDecimalNumber: (val: number) => number;
+declare const longHexNumber: (val: string) => string;
+declare const shortHexNumber: (val: string) => string;
+declare const uCharHexNumber: (val: string) => string;
+declare const universalMeasureValue: (val: UniversalMeasure) => UniversalMeasure;
+declare const positiveUniversalMeasureValue: (val: PositiveUniversalMeasure) => PositiveUniversalMeasure;
+declare const hexColorValue: (val: string) => string;
+declare const signedTwipsMeasureValue: (val: UniversalMeasure | number) => UniversalMeasure | number;
+declare const hpsMeasureValue: (val: PositiveUniversalMeasure | number) => string | number;
+declare const signedHpsMeasureValue: (val: UniversalMeasure | number) => string | number;
+declare const twipsMeasureValue: (val: PositiveUniversalMeasure | number) => PositiveUniversalMeasure | number;
+declare const percentageValue: (val: Percentage) => Percentage;
+declare const measurementOrPercentValue: (val: number | Percentage | UniversalMeasure) => number | UniversalMeasure | Percentage;
+declare const eighthPointMeasureValue: (val: number) => number;
+declare const pointMeasureValue: (val: number) => number;
+declare const dateTimeValue: (val: Date) => string;
+//#endregion
+//#region src/file/table/grid.d.ts
+interface ITableGridChangeOptions {
+  readonly id: number;
+  readonly columnWidths: readonly number[] | readonly PositiveUniversalMeasure[];
+}
+//#endregion
+//#region src/file/table/table-cell-spacing.d.ts
+declare const CellSpacingType: {
+  readonly DXA: "dxa";
+  readonly NIL: "nil";
+};
+interface ITableCellSpacingProperties {
+  readonly value: number | Percentage | UniversalMeasure;
+  readonly type?: (typeof CellSpacingType)[keyof typeof CellSpacingType];
+}
+//#endregion
+//#region src/file/track-revision/track-revision.d.ts
+interface IChangedAttributesProperties {
+  readonly id: number;
+  readonly author: string;
+  readonly date: string;
+}
+//#endregion
+//#region src/file/shading/shading.d.ts
+interface IShadingAttributesProperties {
+  readonly fill?: string;
+  readonly color?: string;
+  readonly type?: (typeof ShadingType)[keyof typeof ShadingType];
+}
+declare const createShading: ({
+  fill,
+  color,
+  type
+}: IShadingAttributesProperties) => XmlComponent;
+declare const ShadingType: {
+  readonly CLEAR: "clear";
+  readonly DIAGONAL_CROSS: "diagCross";
+  readonly DIAGONAL_STRIPE: "diagStripe";
+  readonly HORIZONTAL_CROSS: "horzCross";
+  readonly HORIZONTAL_STRIPE: "horzStripe";
+  readonly NIL: "nil";
+  readonly PERCENT_10: "pct10";
+  readonly PERCENT_12: "pct12";
+  readonly PERCENT_15: "pct15";
+  readonly PERCENT_20: "pct20";
+  readonly PERCENT_25: "pct25";
+  readonly PERCENT_30: "pct30";
+  readonly PERCENT_35: "pct35";
+  readonly PERCENT_37: "pct37";
+  readonly PERCENT_40: "pct40";
+  readonly PERCENT_45: "pct45";
+  readonly PERCENT_5: "pct5";
+  readonly PERCENT_50: "pct50";
+  readonly PERCENT_55: "pct55";
+  readonly PERCENT_60: "pct60";
+  readonly PERCENT_62: "pct62";
+  readonly PERCENT_65: "pct65";
+  readonly PERCENT_70: "pct70";
+  readonly PERCENT_75: "pct75";
+  readonly PERCENT_80: "pct80";
+  readonly PERCENT_85: "pct85";
+  readonly PERCENT_87: "pct87";
+  readonly PERCENT_90: "pct90";
+  readonly PERCENT_95: "pct95";
+  readonly REVERSE_DIAGONAL_STRIPE: "reverseDiagStripe";
+  readonly SOLID: "solid";
+  readonly THIN_DIAGONAL_CROSS: "thinDiagCross";
+  readonly THIN_DIAGONAL_STRIPE: "thinDiagStripe";
+  readonly THIN_HORIZONTAL_CROSS: "thinHorzCross";
+  readonly THIN_REVERSE_DIAGONAL_STRIPE: "thinReverseDiagStripe";
+  readonly THIN_VERTICAL_STRIPE: "thinVertStripe";
+  readonly VERTICAL_STRIPE: "vertStripe";
+};
+//#endregion
+//#region src/file/table/table-width.d.ts
+declare const WidthType: {
+  readonly AUTO: "auto";
+  readonly DXA: "dxa";
+  readonly NIL: "nil";
+  readonly PERCENTAGE: "pct";
+};
+interface ITableWidthProperties {
+  readonly size: number | Percentage | UniversalMeasure;
+  readonly type?: (typeof WidthType)[keyof typeof WidthType];
+}
+declare const createTableWidthElement: (name: string, {
+  type,
+  size
+}: ITableWidthProperties) => XmlComponent;
+//#endregion
+//#region src/file/border/border.d.ts
+interface IBorderOptions {
+  readonly style: (typeof BorderStyle)[keyof typeof BorderStyle];
+  readonly color?: string;
+  readonly size?: number;
+  readonly space?: number;
+}
+declare const createBorderElement: (elementName: string, {
+  color,
+  size,
+  space,
+  style
+}: IBorderOptions) => XmlComponent;
+declare const BorderStyle: {
+  readonly SINGLE: "single";
+  readonly DASH_DOT_STROKED: "dashDotStroked";
+  readonly DASHED: "dashed";
+  readonly DASH_SMALL_GAP: "dashSmallGap";
+  readonly DOT_DASH: "dotDash";
+  readonly DOT_DOT_DASH: "dotDotDash";
+  readonly DOTTED: "dotted";
+  readonly DOUBLE: "double";
+  readonly DOUBLE_WAVE: "doubleWave";
+  readonly INSET: "inset";
+  readonly NIL: "nil";
+  readonly NONE: "none";
+  readonly OUTSET: "outset";
+  readonly THICK: "thick";
+  readonly THICK_THIN_LARGE_GAP: "thickThinLargeGap";
+  readonly THICK_THIN_MEDIUM_GAP: "thickThinMediumGap";
+  readonly THICK_THIN_SMALL_GAP: "thickThinSmallGap";
+  readonly THIN_THICK_LARGE_GAP: "thinThickLargeGap";
+  readonly THIN_THICK_MEDIUM_GAP: "thinThickMediumGap";
+  readonly THIN_THICK_SMALL_GAP: "thinThickSmallGap";
+  readonly THIN_THICK_THIN_LARGE_GAP: "thinThickThinLargeGap";
+  readonly THIN_THICK_THIN_MEDIUM_GAP: "thinThickThinMediumGap";
+  readonly THIN_THICK_THIN_SMALL_GAP: "thinThickThinSmallGap";
+  readonly THREE_D_EMBOSS: "threeDEmboss";
+  readonly THREE_D_ENGRAVE: "threeDEngrave";
+  readonly TRIPLE: "triple";
+  readonly WAVE: "wave";
+};
+//#endregion
+//#region src/file/table/table-properties/table-borders.d.ts
+interface ITableBordersOptions {
+  readonly top?: IBorderOptions;
+  readonly bottom?: IBorderOptions;
+  readonly left?: IBorderOptions;
+  readonly right?: IBorderOptions;
+  readonly insideHorizontal?: IBorderOptions;
+  readonly insideVertical?: IBorderOptions;
+}
+declare class TableBorders extends XmlComponent {
+  static readonly NONE: ITableBordersOptions;
+  constructor(options: ITableBordersOptions);
+}
+//#endregion
+//#region src/file/table/table-properties/table-cell-margin.d.ts
+interface ITableCellMarginOptions {
+  readonly marginUnitType?: (typeof WidthType)[keyof typeof WidthType];
+  readonly top?: number;
+  readonly bottom?: number;
+  readonly left?: number;
+  readonly right?: number;
+}
+//#endregion
+//#region src/file/table/table-properties/table-float-properties.d.ts
+declare const TableAnchorType: {
+  readonly MARGIN: "margin";
+  readonly PAGE: "page";
+  readonly TEXT: "text";
+};
+declare const RelativeHorizontalPosition: {
+  readonly CENTER: "center";
+  readonly INSIDE: "inside";
+  readonly LEFT: "left";
+  readonly OUTSIDE: "outside";
+  readonly RIGHT: "right";
+};
+declare const RelativeVerticalPosition: {
+  readonly BOTTOM: "bottom";
+  readonly CENTER: "center";
+  readonly INLINE: "inline";
+  readonly INSIDE: "inside";
+  readonly OUTSIDE: "outside";
+  readonly TOP: "top";
+};
+declare const OverlapType: {
+  readonly NEVER: "never";
+  readonly OVERLAP: "overlap";
+};
+interface ITableFloatOptions {
+  readonly horizontalAnchor?: (typeof TableAnchorType)[keyof typeof TableAnchorType];
+  readonly absoluteHorizontalPosition?: number | UniversalMeasure;
+  readonly relativeHorizontalPosition?: (typeof RelativeHorizontalPosition)[keyof typeof RelativeHorizontalPosition];
+  readonly verticalAnchor?: (typeof TableAnchorType)[keyof typeof TableAnchorType];
+  readonly absoluteVerticalPosition?: number | UniversalMeasure;
+  readonly relativeVerticalPosition?: (typeof RelativeVerticalPosition)[keyof typeof RelativeVerticalPosition];
+  readonly bottomFromText?: number | PositiveUniversalMeasure;
+  readonly topFromText?: number | PositiveUniversalMeasure;
+  readonly leftFromText?: number | PositiveUniversalMeasure;
+  readonly rightFromText?: number | PositiveUniversalMeasure;
+  readonly overlap?: (typeof OverlapType)[keyof typeof OverlapType];
+}
+declare const createTableFloatProperties: ({
+  horizontalAnchor,
+  verticalAnchor,
+  absoluteHorizontalPosition,
+  relativeHorizontalPosition,
+  absoluteVerticalPosition,
+  relativeVerticalPosition,
+  bottomFromText,
+  topFromText,
+  leftFromText,
+  rightFromText,
+  overlap
+}: ITableFloatOptions) => XmlComponent;
+//#endregion
+//#region src/file/table/table-properties/table-layout.d.ts
+declare const TableLayoutType: {
+  readonly AUTOFIT: "autofit";
+  readonly FIXED: "fixed";
+};
+declare const createTableLayout: (type: (typeof TableLayoutType)[keyof typeof TableLayoutType]) => XmlComponent;
+//#endregion
+//#region src/file/table/table-properties/table-look.d.ts
+interface ITableLookOptions {
+  readonly firstRow?: boolean;
+  readonly lastRow?: boolean;
+  readonly firstColumn?: boolean;
+  readonly lastColumn?: boolean;
+  readonly noHBand?: boolean;
+  readonly noVBand?: boolean;
+}
+declare const createTableLook: ({
+  firstRow,
+  lastRow,
+  firstColumn,
+  lastColumn,
+  noHBand,
+  noVBand
+}: ITableLookOptions) => XmlComponent;
+//#endregion
+//#region src/file/table/table-properties/table-properties.d.ts
+interface ITablePropertiesOptionsBase {
+  readonly width?: ITableWidthProperties;
+  readonly indent?: ITableWidthProperties;
+  readonly layout?: (typeof TableLayoutType)[keyof typeof TableLayoutType];
+  readonly borders?: ITableBordersOptions;
+  readonly float?: ITableFloatOptions;
+  readonly shading?: IShadingAttributesProperties;
+  readonly style?: string;
+  readonly alignment?: (typeof AlignmentType)[keyof typeof AlignmentType];
+  readonly cellMargin?: ITableCellMarginOptions;
+  readonly visuallyRightToLeft?: boolean;
+  readonly tableLook?: ITableLookOptions;
+  readonly cellSpacing?: ITableCellSpacingProperties;
+}
+type ITablePropertiesChangeOptions = ITablePropertiesOptions & IChangedAttributesProperties;
+type ITablePropertiesOptions = {
+  readonly revision?: ITablePropertiesChangeOptions;
+  readonly includeIfEmpty?: boolean;
+} & ITablePropertiesOptionsBase;
+declare class TableProperties extends IgnoreIfEmptyXmlComponent {
+  constructor(options: ITablePropertiesOptions);
+}
+//#endregion
+//#region src/file/track-revision/track-revision-components/inserted-text-run.d.ts
+type IInsertedRunOptions = IChangedAttributesProperties & IRunOptions;
+declare class InsertedTextRun extends XmlComponent {
+  constructor(options: IInsertedRunOptions);
+}
+//#endregion
+//#region src/file/paragraph/run/emphasis-mark.d.ts
+declare const EmphasisMarkType: {
+  readonly DOT: "dot";
+};
+declare const createEmphasisMark: (emphasisMarkType?: (typeof EmphasisMarkType)[keyof typeof EmphasisMarkType]) => XmlComponent;
+declare const createDotEmphasisMark: () => XmlComponent;
+//#endregion
+//#region src/file/paragraph/run/language.d.ts
+interface ILanguageOptions {
+  readonly value?: string;
+  readonly eastAsia?: string;
+  readonly bidirectional?: string;
+}
+//#endregion
+//#region src/file/paragraph/run/run-fonts.d.ts
+interface IFontAttributesProperties {
+  readonly ascii?: string;
+  readonly cs?: string;
+  readonly eastAsia?: string;
+  readonly hAnsi?: string;
+  readonly hint?: string;
+}
+declare const createRunFonts: (nameOrAttrs: string | IFontAttributesProperties, hint?: string) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/run/underline.d.ts
+declare const UnderlineType: {
+  readonly SINGLE: "single";
+  readonly WORDS: "words";
+  readonly DOUBLE: "double";
+  readonly THICK: "thick";
+  readonly DOTTED: "dotted";
+  readonly DOTTEDHEAVY: "dottedHeavy";
+  readonly DASH: "dash";
+  readonly DASHEDHEAVY: "dashedHeavy";
+  readonly DASHLONG: "dashLong";
+  readonly DASHLONGHEAVY: "dashLongHeavy";
+  readonly DOTDASH: "dotDash";
+  readonly DASHDOTHEAVY: "dashDotHeavy";
+  readonly DOTDOTDASH: "dotDotDash";
+  readonly DASHDOTDOTHEAVY: "dashDotDotHeavy";
+  readonly WAVE: "wave";
+  readonly WAVYHEAVY: "wavyHeavy";
+  readonly WAVYDOUBLE: "wavyDouble";
+  readonly NONE: "none";
+};
+declare const createUnderline: (underlineType?: (typeof UnderlineType)[keyof typeof UnderlineType], color?: string) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/run/properties.d.ts
+interface IFontOptions {
+  readonly name: string;
+  readonly hint?: string;
+}
+declare const TextEffect: {
+  readonly BLINK_BACKGROUND: "blinkBackground";
+  readonly LIGHTS: "lights";
+  readonly ANTS_BLACK: "antsBlack";
+  readonly ANTS_RED: "antsRed";
+  readonly SHIMMER: "shimmer";
+  readonly SPARKLE: "sparkle";
+  readonly NONE: "none";
+};
+declare const HighlightColor: {
+  readonly BLACK: "black";
+  readonly BLUE: "blue";
+  readonly CYAN: "cyan";
+  readonly DARK_BLUE: "darkBlue";
+  readonly DARK_CYAN: "darkCyan";
+  readonly DARK_GRAY: "darkGray";
+  readonly DARK_GREEN: "darkGreen";
+  readonly DARK_MAGENTA: "darkMagenta";
+  readonly DARK_RED: "darkRed";
+  readonly DARK_YELLOW: "darkYellow";
+  readonly GREEN: "green";
+  readonly LIGHT_GRAY: "lightGray";
+  readonly MAGENTA: "magenta";
+  readonly NONE: "none";
+  readonly RED: "red";
+  readonly WHITE: "white";
+  readonly YELLOW: "yellow";
+};
+interface IRunStylePropertiesOptions {
+  readonly noProof?: boolean;
+  readonly bold?: boolean;
+  readonly boldComplexScript?: boolean;
+  readonly italics?: boolean;
+  readonly italicsComplexScript?: boolean;
+  readonly underline?: {
+    readonly color?: string;
+    readonly type?: (typeof UnderlineType)[keyof typeof UnderlineType];
+  };
+  readonly effect?: (typeof TextEffect)[keyof typeof TextEffect];
+  readonly emphasisMark?: {
+    readonly type?: (typeof EmphasisMarkType)[keyof typeof EmphasisMarkType];
+  };
+  readonly color?: string;
+  readonly kern?: number | PositiveUniversalMeasure;
+  readonly position?: UniversalMeasure;
+  readonly size?: number | PositiveUniversalMeasure;
+  readonly sizeComplexScript?: boolean | number | PositiveUniversalMeasure;
+  readonly rightToLeft?: boolean;
+  readonly smallCaps?: boolean;
+  readonly allCaps?: boolean;
+  readonly strike?: boolean;
+  readonly doubleStrike?: boolean;
+  readonly subScript?: boolean;
+  readonly superScript?: boolean;
+  readonly font?: string | IFontOptions | IFontAttributesProperties;
+  readonly highlight?: (typeof HighlightColor)[keyof typeof HighlightColor];
+  readonly highlightComplexScript?: boolean | string;
+  readonly characterSpacing?: number;
+  readonly shading?: IShadingAttributesProperties;
+  readonly emboss?: boolean;
+  readonly imprint?: boolean;
+  readonly revision?: IRunPropertiesChangeOptions;
+  readonly language?: ILanguageOptions;
+  readonly border?: IBorderOptions;
+  readonly snapToGrid?: boolean;
+  readonly vanish?: boolean;
+  readonly specVanish?: boolean;
+  readonly scale?: number;
+  readonly math?: boolean;
+}
+type IRunPropertiesOptions = {
+  readonly style?: string;
+} & IRunStylePropertiesOptions;
+type IRunPropertiesChangeOptions = {} & IRunPropertiesOptions & IChangedAttributesProperties;
+type IParagraphRunPropertiesOptions = {
+  readonly insertion?: IChangedAttributesProperties;
+  readonly deletion?: IChangedAttributesProperties;
+} & IRunPropertiesOptions;
+declare class RunProperties extends IgnoreIfEmptyXmlComponent {
+  constructor(options?: IRunPropertiesOptions);
+  push(item: XmlComponent): void;
+}
+declare class ParagraphRunProperties extends RunProperties {
+  constructor(options?: IParagraphRunPropertiesOptions);
+}
+declare class RunPropertiesChange extends XmlComponent {
+  constructor(options: IRunPropertiesChangeOptions);
+}
+//#endregion
+//#region src/file/paragraph/run/text-run.d.ts
+declare class TextRun extends Run {
+  constructor(options: IRunOptions | string);
+}
+//#endregion
+//#region src/file/paragraph/run/symbol-run.d.ts
+type ISymbolRunOptions = {
+  readonly char: string;
+  readonly symbolfont?: string;
+} & IRunOptions;
+declare class SymbolRun extends Run {
+  constructor(options: ISymbolRunOptions | string);
+}
+//#endregion
+//#region src/file/drawing/doc-properties/doc-properties.d.ts
+interface DocPropertiesOptions {
+  readonly name: string;
+  readonly description?: string;
+  readonly title?: string;
+  readonly id?: string;
+}
+//#endregion
+//#region src/file/drawing/inline/graphic/graphic-data/pic/shape-properties/outline/scheme-color.d.ts
+declare const SchemeColor: {
+  readonly BG1: "bg1";
+  readonly TX1: "tx1";
+  readonly BG2: "bg2";
+  readonly TX2: "tx2";
+  readonly ACCENT1: "accent1";
+  readonly ACCENT2: "accent2";
+  readonly ACCENT3: "accent3";
+  readonly ACCENT4: "accent4";
+  readonly ACCENT5: "accent5";
+  readonly ACCENT6: "accent6";
+  readonly HLINK: "hlink";
+  readonly FOLHLINK: "folHlink";
+  readonly DK1: "dk1";
+  readonly LT1: "lt1";
+  readonly DK2: "dk2";
+  readonly LT2: "lt2";
+  readonly PHCLR: "phClr";
+};
+//#endregion
+//#region src/file/drawing/inline/graphic/graphic-data/pic/shape-properties/outline/outline.d.ts
+declare const LineCap: {
+  readonly ROUND: "rnd";
+  readonly SQUARE: "sq";
+  readonly FLAT: "flat";
+};
+declare const CompoundLine: {
+  readonly SINGLE: "sng";
+  readonly DOUBLE: "dbl";
+  readonly THICK_THIN: "thickThin";
+  readonly THIN_THICK: "thinThick";
+  readonly TRI: "tri";
+};
+declare const PenAlignment: {
+  readonly CENTER: "ctr";
+  readonly INSET: "in";
+};
+interface OutlineAttributes {
+  readonly width?: number;
+  readonly cap?: keyof typeof LineCap;
+  readonly compoundLine?: keyof typeof CompoundLine;
+  readonly align?: keyof typeof PenAlignment;
+}
+interface OutlineNoFill {
+  readonly type: "noFill";
+}
+interface OutlineRgbSolidFill {
+  readonly type: "solidFill";
+  readonly solidFillType: "rgb";
+  readonly value: string;
+}
+interface OutlineSchemeSolidFill {
+  readonly type: "solidFill";
+  readonly solidFillType: "scheme";
+  readonly value: (typeof SchemeColor)[keyof typeof SchemeColor];
+}
+type OutlineSolidFill = OutlineRgbSolidFill | OutlineSchemeSolidFill;
+type OutlineFillProperties = OutlineNoFill | OutlineSolidFill;
+type OutlineOptions = OutlineAttributes & OutlineFillProperties;
+//#endregion
+//#region src/file/drawing/inline/graphic/graphic-data/pic/shape-properties/outline/solid-fill.d.ts
+interface RgbColorOptions {
+  readonly type: "rgb";
+  readonly value: string;
+}
+interface SchemeColorOptions {
+  readonly type: "scheme";
+  readonly value: (typeof SchemeColor)[keyof typeof SchemeColor];
+}
+type SolidFillOptions = RgbColorOptions | SchemeColorOptions;
+//#endregion
+//#region src/file/drawing/text-wrap/text-wrapping.d.ts
+declare const TextWrappingType: {
+  readonly NONE: 0;
+  readonly SQUARE: 1;
+  readonly TIGHT: 2;
+  readonly TOP_AND_BOTTOM: 3;
+};
+declare const TextWrappingSide: {
+  readonly BOTH_SIDES: "bothSides";
+  readonly LEFT: "left";
+  readonly RIGHT: "right";
+  readonly LARGEST: "largest";
+};
+interface ITextWrapping {
+  readonly type: (typeof TextWrappingType)[keyof typeof TextWrappingType];
+  readonly side?: (typeof TextWrappingSide)[keyof typeof TextWrappingSide];
+  readonly margins?: IDistance;
+}
+//#endregion
+//#region src/file/drawing/text-wrap/wrap-none.d.ts
+declare const createWrapNone: () => XmlComponent;
+//#endregion
+//#region src/file/shared/alignment.d.ts
+declare const HorizontalPositionAlign: {
+  readonly CENTER: "center";
+  readonly INSIDE: "inside";
+  readonly LEFT: "left";
+  readonly OUTSIDE: "outside";
+  readonly RIGHT: "right";
+};
+declare const VerticalPositionAlign: {
+  readonly BOTTOM: "bottom";
+  readonly CENTER: "center";
+  readonly INSIDE: "inside";
+  readonly OUTSIDE: "outside";
+  readonly TOP: "top";
+};
+//#endregion
+//#region src/file/drawing/floating/floating-position.d.ts
+declare const HorizontalPositionRelativeFrom: {
+  readonly CHARACTER: "character";
+  readonly COLUMN: "column";
+  readonly INSIDE_MARGIN: "insideMargin";
+  readonly LEFT_MARGIN: "leftMargin";
+  readonly MARGIN: "margin";
+  readonly OUTSIDE_MARGIN: "outsideMargin";
+  readonly PAGE: "page";
+  readonly RIGHT_MARGIN: "rightMargin";
+};
+declare const VerticalPositionRelativeFrom: {
+  readonly BOTTOM_MARGIN: "bottomMargin";
+  readonly INSIDE_MARGIN: "insideMargin";
+  readonly LINE: "line";
+  readonly MARGIN: "margin";
+  readonly OUTSIDE_MARGIN: "outsideMargin";
+  readonly PAGE: "page";
+  readonly PARAGRAPH: "paragraph";
+  readonly TOP_MARGIN: "topMargin";
+};
+interface IHorizontalPositionOptions {
+  readonly relative?: (typeof HorizontalPositionRelativeFrom)[keyof typeof HorizontalPositionRelativeFrom];
+  readonly align?: (typeof HorizontalPositionAlign)[keyof typeof HorizontalPositionAlign];
+  readonly offset?: number;
+}
+interface IVerticalPositionOptions {
+  readonly relative?: (typeof VerticalPositionRelativeFrom)[keyof typeof VerticalPositionRelativeFrom];
+  readonly align?: (typeof VerticalPositionAlign)[keyof typeof VerticalPositionAlign];
+  readonly offset?: number;
+}
+interface IMargins {
+  readonly left?: number;
+  readonly bottom?: number;
+  readonly top?: number;
+  readonly right?: number;
+}
+interface IFloating {
+  readonly horizontalPosition: IHorizontalPositionOptions;
+  readonly verticalPosition: IVerticalPositionOptions;
+  readonly allowOverlap?: boolean;
+  readonly lockAnchor?: boolean;
+  readonly behindDocument?: boolean;
+  readonly layoutInCell?: boolean;
+  readonly margins?: IMargins;
+  readonly wrap?: ITextWrapping;
+  readonly zIndex?: number;
+}
+//#endregion
+//#region src/file/drawing/floating/simple-pos.d.ts
+declare const createSimplePos: () => XmlComponent;
+//#endregion
+//#region src/file/drawing/floating/horizontal-position.d.ts
+declare const createHorizontalPosition: ({
+  relative,
+  align,
+  offset
+}: IHorizontalPositionOptions) => XmlComponent;
+//#endregion
+//#region src/file/drawing/floating/vertical-position.d.ts
+declare const createVerticalPosition: ({
+  relative,
+  align,
+  offset
+}: IVerticalPositionOptions) => XmlComponent;
+//#endregion
+//#region src/file/drawing/text-wrap/wrap-square.d.ts
+declare const createWrapSquare: (textWrapping: ITextWrapping, margins?: IMargins) => XmlComponent;
+//#endregion
+//#region src/file/drawing/text-wrap/wrap-tight.d.ts
+declare const createWrapTight: (margins?: IMargins) => XmlComponent;
+//#endregion
+//#region src/file/drawing/text-wrap/wrap-top-and-bottom.d.ts
+declare const createWrapTopAndBottom: (margins?: IMargins) => XmlComponent;
+//#endregion
+//#region src/file/drawing/inline/graphic/graphic-data/wps/body-properties.d.ts
+declare enum VerticalAnchor {
+  CENTER = "ctr",
+  TOP = "t",
+  BOTTOM = "b"
+}
+interface IBodyPropertiesOptions {
+  readonly wrap?: (typeof TextWrappingType)[keyof typeof TextWrappingType];
+  readonly verticalAnchor?: VerticalAnchor;
+  readonly margins?: {
+    readonly top?: number;
+    readonly bottom?: number;
+    readonly left?: number;
+    readonly right?: number;
+  };
+  readonly noAutoFit?: boolean;
+}
+declare const createBodyProperties: (options?: IBodyPropertiesOptions) => XmlComponent;
+//#endregion
+//#region src/file/drawing/inline/graphic/graphic-data/wps/non-visual-shape-properties.d.ts
+interface INonVisualShapePropertiesOptions {
+  readonly txBox: string;
+}
+//#endregion
+//#region src/file/drawing/inline/graphic/graphic-data/wps/wps-shape.d.ts
+interface WpsShapeCoreOptions {
+  readonly children: readonly Paragraph[];
+  readonly nonVisualProperties?: INonVisualShapePropertiesOptions;
+  readonly bodyProperties?: IBodyPropertiesOptions;
+}
+//#endregion
+//#region src/file/media/data.d.ts
+interface IMediaDataTransformation {
+  readonly offset?: {
+    readonly pixels: {
+      readonly x: number;
+      readonly y: number;
+    };
+    readonly emus?: {
+      readonly x: number;
+      readonly y: number;
+    };
+  };
+  readonly pixels: {
+    readonly x: number;
+    readonly y: number;
+  };
+  readonly emus: {
+    readonly x: number;
+    readonly y: number;
+  };
+  readonly flip?: {
+    readonly vertical?: boolean;
+    readonly horizontal?: boolean;
+  };
+  readonly rotation?: number;
+}
+interface CoreMediaData {
+  readonly fileName: string;
+  readonly transformation: IMediaDataTransformation;
+  readonly data: Buffer | Uint8Array | ArrayBuffer;
+}
+interface RegularMediaData {
+  readonly type: "jpg" | "png" | "gif" | "bmp";
+}
+interface SvgMediaData {
+  readonly type: "svg";
+  readonly fallback: RegularMediaData & CoreMediaData;
+}
+interface WpsMediaData {
+  readonly type: "wps";
+  readonly transformation: IMediaDataTransformation;
+  readonly data: WpsShapeCoreOptions;
+}
+interface WpgCommonMediaData {
+  readonly outline?: OutlineOptions;
+  readonly solidFill?: SolidFillOptions;
+}
+type IGroupChildMediaData = (WpsMediaData | IMediaData) & WpgCommonMediaData;
+interface WpgMediaData {
+  readonly type: "wpg";
+  readonly transformation: IMediaDataTransformation;
+  readonly children: readonly IGroupChildMediaData[];
+}
+type IExtendedMediaData = IMediaData | WpsMediaData | WpgMediaData;
+type IMediaData = (RegularMediaData | SvgMediaData) & CoreMediaData;
+declare const WORKAROUND2 = "";
+//#endregion
+//#region src/file/media/media.d.ts
+interface IMediaTransformation {
+  readonly offset?: {
+    readonly top?: number;
+    readonly left?: number;
+  };
+  readonly width: number;
+  readonly height: number;
+  readonly flip?: {
+    readonly vertical?: boolean;
+    readonly horizontal?: boolean;
+  };
+  readonly rotation?: number;
+}
+declare class Media {
+  private readonly map;
+  constructor();
+  addImage(key: string, mediaData: IMediaData): void;
+  get Array(): readonly IMediaData[];
+}
+//#endregion
+//#region src/file/drawing/drawing.d.ts
+interface IDistance {
+  readonly distT?: number;
+  readonly distB?: number;
+  readonly distL?: number;
+  readonly distR?: number;
+}
+interface IDrawingOptions {
+  readonly floating?: IFloating;
+  readonly docProperties?: DocPropertiesOptions;
+  readonly outline?: OutlineOptions;
+  readonly solidFill?: SolidFillOptions;
+}
+declare class Drawing extends XmlComponent {
+  constructor(imageData: IExtendedMediaData, drawingOptions?: IDrawingOptions);
+}
+//#endregion
+//#region src/file/paragraph/run/image-run.d.ts
+interface CoreImageOptions {
+  readonly transformation: IMediaTransformation;
+  readonly floating?: IFloating;
+  readonly altText?: DocPropertiesOptions;
+  readonly outline?: OutlineOptions;
+  readonly solidFill?: SolidFillOptions;
+}
+interface RegularImageOptions {
+  readonly type: "jpg" | "png" | "gif" | "bmp";
+  readonly data: Buffer | string | Uint8Array | ArrayBuffer;
+}
+interface SvgMediaOptions {
+  readonly type: "svg";
+  readonly data: Buffer | string | Uint8Array | ArrayBuffer;
+  readonly fallback: RegularImageOptions;
+}
+type IImageOptions = (RegularImageOptions | SvgMediaOptions) & CoreImageOptions;
+declare const standardizeData: (data: string | Buffer | Uint8Array | ArrayBuffer) => Buffer | Uint8Array | ArrayBuffer;
+declare class ImageRun extends Run {
+  private readonly imageData;
+  constructor(options: IImageOptions);
+  prepForXml(context: IContext): IXmlableObject | undefined;
+}
+//#endregion
+//#region src/file/paragraph/run/wps-shape-run.d.ts
+interface CoreShapeOptions {
+  readonly transformation: IMediaTransformation;
+  readonly floating?: IFloating;
+  readonly altText?: DocPropertiesOptions;
+  readonly outline?: OutlineOptions;
+  readonly solidFill?: SolidFillOptions;
+}
+type IWpsShapeOptions = WpsShapeCoreOptions & {
+  readonly type: "wps";
+} & CoreShapeOptions;
+declare const createTransformation: (options: IMediaTransformation) => IMediaDataTransformation;
+declare class WpsShapeRun extends Run {
+  private readonly wpsShapeData;
+  constructor(options: IWpsShapeOptions);
+}
+//#endregion
+//#region src/file/paragraph/run/wpg-group-run.d.ts
+interface CoreGroupOptions {
+  readonly children: readonly IGroupChildMediaData[];
+  readonly transformation: IMediaTransformation;
+  readonly floating?: IFloating;
+  readonly altText?: DocPropertiesOptions;
+}
+type IWpgGroupOptions = {
+  readonly type: "wpg";
+} & CoreGroupOptions;
+declare class WpgGroupRun extends Run {
+  private readonly wpgGroupData;
+  private readonly mediaDatas;
+  constructor(options: IWpgGroupOptions);
+  prepForXml(context: IContext): IXmlableObject | undefined;
+}
+//#endregion
+//#region src/file/paragraph/run/sequential-identifier.d.ts
+declare class SequentialIdentifier extends Run {
+  constructor(identifier: string);
+}
+//#endregion
+//#region src/file/paragraph/run/simple-field.d.ts
+declare class SimpleField extends XmlComponent {
+  constructor(instruction: string, cachedValue?: string);
+}
+declare class SimpleMailMergeField extends SimpleField {
+  constructor(fieldName: string);
+}
+//#endregion
+//#region src/file/relationships/relationship/relationship.d.ts
+type RelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" | "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments" | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/font";
+declare const TargetModeType: {
+  readonly EXTERNAL: "External";
+};
+//#endregion
+//#region src/file/relationships/relationships.d.ts
+declare class Relationships extends XmlComponent {
+  constructor();
+  addRelationship(id: number | string, type: RelationshipType, target: string, targetMode?: (typeof TargetModeType)[keyof typeof TargetModeType]): void;
+  get RelationshipCount(): number;
+}
+//#endregion
+//#region src/file/paragraph/run/comment-run.d.ts
+interface ICommentOptions {
+  readonly id: number;
+  readonly children: readonly FileChild[];
+  readonly initials?: string;
+  readonly author?: string;
+  readonly date?: Date;
+}
+interface ICommentsOptions {
+  readonly children: readonly ICommentOptions[];
+}
+declare class CommentRangeStart extends XmlComponent {
+  constructor(id: number);
+}
+declare class CommentRangeEnd extends XmlComponent {
+  constructor(id: number);
+}
+declare class CommentReference extends XmlComponent {
+  constructor(id: number);
+}
+declare class Comment extends XmlComponent {
+  constructor({
+    id,
+    initials,
+    author,
+    date,
+    children
+  }: ICommentOptions);
+}
+declare class Comments extends XmlComponent {
+  private readonly relationships;
+  constructor({
+    children
+  }: ICommentsOptions);
+  get Relationships(): Relationships;
+}
+//#endregion
+//#region src/file/paragraph/run/empty-children.d.ts
+declare class NoBreakHyphen extends EmptyElement {
+  constructor();
+}
+declare class SoftHyphen extends EmptyElement {
+  constructor();
+}
+declare class DayShort extends EmptyElement {
+  constructor();
+}
+declare class MonthShort extends EmptyElement {
+  constructor();
+}
+declare class YearShort extends EmptyElement {
+  constructor();
+}
+declare class DayLong extends EmptyElement {
+  constructor();
+}
+declare class MonthLong extends EmptyElement {
+  constructor();
+}
+declare class YearLong extends EmptyElement {
+  constructor();
+}
+declare class AnnotationReference extends EmptyElement {
+  constructor();
+}
+declare class FootnoteReferenceElement extends EmptyElement {
+  constructor();
+}
+declare class EndnoteReference extends EmptyElement {
+  constructor();
+}
+declare class Separator extends EmptyElement {
+  constructor();
+}
+declare class ContinuationSeparator extends EmptyElement {
+  constructor();
+}
+declare class PageNumberElement extends EmptyElement {
+  constructor();
+}
+declare class CarriageReturn extends EmptyElement {
+  constructor();
+}
+declare class Tab extends EmptyElement {
+  constructor();
+}
+declare class LastRenderedPageBreak extends EmptyElement {
+  constructor();
+}
+//#endregion
+//#region src/file/paragraph/run/positional-tab.d.ts
+declare const PositionalTabAlignment: {
+  readonly LEFT: "left";
+  readonly CENTER: "center";
+  readonly RIGHT: "right";
+};
+declare const PositionalTabRelativeTo: {
+  readonly MARGIN: "margin";
+  readonly INDENT: "indent";
+};
+declare const PositionalTabLeader: {
+  readonly NONE: "none";
+  readonly DOT: "dot";
+  readonly HYPHEN: "hyphen";
+  readonly UNDERSCORE: "underscore";
+  readonly MIDDLE_DOT: "middleDot";
+};
+interface PositionalTabOptions {
+  readonly alignment: (typeof PositionalTabAlignment)[keyof typeof PositionalTabAlignment];
+  readonly relativeTo: (typeof PositionalTabRelativeTo)[keyof typeof PositionalTabRelativeTo];
+  readonly leader: (typeof PositionalTabLeader)[keyof typeof PositionalTabLeader];
+}
+declare class PositionalTab extends XmlComponent {
+  constructor(options: PositionalTabOptions);
+}
+//#endregion
+//#region src/file/footnotes/footnote/run/reference-run.d.ts
+declare class FootNoteReferenceRunAttributes extends XmlAttributeComponent<{
+  readonly id: number;
+}> {
+  protected readonly xmlKeys: {
+    id: string;
+  };
+}
+declare class FootnoteReference extends XmlComponent {
+  constructor(id: number);
+}
+declare class FootnoteReferenceRun extends Run {
+  constructor(id: number);
+}
+//#endregion
+//#region src/file/table-of-contents/table-of-contents-properties.d.ts
+declare class StyleLevel {
+  readonly styleName: string;
+  readonly level: number;
+  constructor(styleName: string, level: number);
+}
+interface ITableOfContentsOptions {
+  readonly captionLabel?: string;
+  readonly entriesFromBookmark?: string;
+  readonly captionLabelIncludingNumbers?: string;
+  readonly sequenceAndPageNumbersSeparator?: string;
+  readonly tcFieldIdentifier?: string;
+  readonly hyperlink?: boolean;
+  readonly tcFieldLevelRange?: string;
+  readonly pageNumbersEntryLevelsRange?: string;
+  readonly headingStyleRange?: string;
+  readonly entryAndPageNumberSeparator?: string;
+  readonly seqFieldIdentifierForPrefix?: string;
+  readonly stylesWithLevels?: readonly StyleLevel[];
+  readonly useAppliedParagraphOutlineLevel?: boolean;
+  readonly preserveTabInEntries?: boolean;
+  readonly preserveNewLineInEntries?: boolean;
+  readonly hideTabAndPageNumbersInWebView?: boolean;
+}
+//#endregion
+//#region src/file/table-of-contents/field-instruction.d.ts
+declare class FieldInstruction extends XmlComponent {
+  private readonly properties;
+  constructor(properties?: ITableOfContentsOptions);
+}
+//#endregion
+//#region src/file/paragraph/run/run.d.ts
+interface IRunOptionsBase {
+  readonly children?: readonly (FieldInstruction | (typeof PageNumber)[keyof typeof PageNumber] | FootnoteReferenceRun | string | AnnotationReference | CarriageReturn | ContinuationSeparator | DayLong | DayShort | EndnoteReference | FootnoteReferenceElement | LastRenderedPageBreak | MonthLong | MonthShort | NoBreakHyphen | PageNumberElement | Separator | SoftHyphen | Tab | YearLong | YearShort | XmlComponent)[];
+  readonly break?: number;
+  readonly text?: string;
+}
+type IRunOptions = IRunOptionsBase & IRunPropertiesOptions;
+type IParagraphRunOptions = IRunOptionsBase & IParagraphRunPropertiesOptions;
+declare const PageNumber: {
+  readonly CURRENT: "CURRENT";
+  readonly TOTAL_PAGES: "TOTAL_PAGES";
+  readonly TOTAL_PAGES_IN_SECTION: "TOTAL_PAGES_IN_SECTION";
+  readonly CURRENT_SECTION: "SECTION";
+};
+declare class Run extends XmlComponent {
+  protected readonly properties: RunProperties;
+  constructor(options: IRunOptions);
+}
+//#endregion
+//#region src/file/track-revision/track-revision-components/deleted-text-run.d.ts
+type IDeletedRunOptions = IRunOptions & IChangedAttributesProperties;
+declare class DeletedTextRun extends XmlComponent {
+  protected readonly deletedTextRunWrapper: DeletedTextRunWrapper;
+  constructor(options: IDeletedRunOptions);
+}
+declare class DeletedTextRunWrapper extends XmlComponent {
+  constructor(options: IRunOptions);
+}
+//#endregion
+//#region src/file/track-revision/track-revision-components/inserted-table-row.d.ts
+declare class InsertedTableRow extends XmlComponent {
+  constructor(options: IChangedAttributesProperties);
+}
+//#endregion
+//#region src/file/track-revision/track-revision-components/deleted-table-row.d.ts
+declare class DeletedTableRow extends XmlComponent {
+  constructor(options: IChangedAttributesProperties);
+}
+//#endregion
+//#region src/file/track-revision/track-revision-components/inserted-table-cell.d.ts
+declare class InsertedTableCell extends XmlComponent {
+  constructor(options: IChangedAttributesProperties);
+}
+//#endregion
+//#region src/file/track-revision/track-revision-components/deleted-table-cell.d.ts
+declare class DeletedTableCell extends XmlComponent {
+  constructor(options: IChangedAttributesProperties);
+}
+//#endregion
+//#region src/file/track-revision/track-revision-components/cell-merge.d.ts
+declare const VerticalMergeRevisionType: {
+  readonly CONTINUE: "cont";
+  readonly RESTART: "rest";
+};
+type ICellMergeAttributes = IChangedAttributesProperties & {
+  readonly verticalMerge?: (typeof VerticalMergeRevisionType)[keyof typeof VerticalMergeRevisionType];
+  readonly verticalMergeOriginal?: (typeof VerticalMergeRevisionType)[keyof typeof VerticalMergeRevisionType];
+};
+declare class CellMergeAttributes extends XmlAttributeComponent<ICellMergeAttributes> {
+  protected readonly xmlKeys: {
+    author: string;
+    date: string;
+    id: string;
+    verticalMerge: string;
+    verticalMergeOriginal: string;
+  };
+}
+declare class CellMerge extends XmlComponent {
+  constructor(options: ICellMergeAttributes);
+}
+//#endregion
+//#region src/file/vertical-align/vertical-align.d.ts
+declare const VerticalAlignTable: {
+  readonly BOTTOM: "bottom";
+  readonly CENTER: "center";
+  readonly TOP: "top";
+};
+declare const VerticalAlignSection: {
+  readonly BOTH: "both";
+  readonly BOTTOM: "bottom";
+  readonly CENTER: "center";
+  readonly TOP: "top";
+};
+declare const VerticalAlign: {
+  readonly BOTH: "both";
+  readonly BOTTOM: "bottom";
+  readonly CENTER: "center";
+  readonly TOP: "top";
+};
+type TableVerticalAlign = (typeof VerticalAlignTable)[keyof typeof VerticalAlignTable];
+type SectionVerticalAlign = (typeof VerticalAlignSection)[keyof typeof VerticalAlignSection];
+declare const createVerticalAlign: (value: (typeof VerticalAlign)[keyof typeof VerticalAlign]) => XmlComponent;
+//#endregion
+//#region src/file/table/table-cell/table-cell-components.d.ts
+interface ITableCellBorders {
+  readonly top?: IBorderOptions;
+  readonly start?: IBorderOptions;
+  readonly left?: IBorderOptions;
+  readonly bottom?: IBorderOptions;
+  readonly end?: IBorderOptions;
+  readonly right?: IBorderOptions;
+}
+declare class TableCellBorders extends IgnoreIfEmptyXmlComponent {
+  constructor(options: ITableCellBorders);
+}
+declare class GridSpan extends XmlComponent {
+  constructor(value: number);
+}
+declare const VerticalMergeType: {
+  readonly CONTINUE: "continue";
+  readonly RESTART: "restart";
+};
+declare class VerticalMerge extends XmlComponent {
+  constructor(value: (typeof VerticalMergeType)[keyof typeof VerticalMergeType]);
+}
+declare const TextDirection: {
+  readonly BOTTOM_TO_TOP_LEFT_TO_RIGHT: "btLr";
+  readonly LEFT_TO_RIGHT_TOP_TO_BOTTOM: "lrTb";
+  readonly TOP_TO_BOTTOM_RIGHT_TO_LEFT: "tbRl";
+};
+declare class TDirection extends XmlComponent {
+  constructor(value: (typeof TextDirection)[keyof typeof TextDirection]);
+}
+//#endregion
+//#region src/file/table/table-cell/table-cell-properties.d.ts
+interface ITableCellPropertiesOptionsBase {
+  readonly shading?: IShadingAttributesProperties;
+  readonly margins?: ITableCellMarginOptions;
+  readonly verticalAlign?: TableVerticalAlign;
+  readonly textDirection?: (typeof TextDirection)[keyof typeof TextDirection];
+  readonly verticalMerge?: (typeof VerticalMergeType)[keyof typeof VerticalMergeType];
+  readonly width?: ITableWidthProperties;
+  readonly columnSpan?: number;
+  readonly rowSpan?: number;
+  readonly borders?: ITableCellBorders;
+  readonly insertion?: IChangedAttributesProperties;
+  readonly deletion?: IChangedAttributesProperties;
+  readonly cellMerge?: ICellMergeAttributes;
+}
+type ITableCellPropertiesOptions = {
+  readonly revision?: ITableCellPropertiesChangeOptions;
+  readonly includeIfEmpty?: boolean;
+} & ITableCellPropertiesOptionsBase;
+type ITableCellPropertiesChangeOptions = ITableCellPropertiesOptionsBase & IChangedAttributesProperties;
+//#endregion
+//#region src/file/table/table-cell/table-cell.d.ts
+type ITableCellOptions = {
+  readonly children: readonly (Paragraph | Table)[];
+} & ITableCellPropertiesOptions;
+declare class TableCell extends XmlComponent {
+  readonly options: ITableCellOptions;
+  constructor(options: ITableCellOptions);
+  prepForXml(context: IContext): IXmlableObject | undefined;
+}
+//#endregion
+//#region src/file/table/table-row/table-row-height.d.ts
+declare const HeightRule: {
+  readonly AUTO: "auto";
+  readonly ATLEAST: "atLeast";
+  readonly EXACT: "exact";
+};
+declare const createTableRowHeight: (value: number | PositiveUniversalMeasure, rule: (typeof HeightRule)[keyof typeof HeightRule]) => XmlComponent;
+//#endregion
+//#region src/file/table/table-row/table-row-properties.d.ts
+interface ITableRowPropertiesOptionsBase {
+  readonly cantSplit?: boolean;
+  readonly tableHeader?: boolean;
+  readonly height?: {
+    readonly value: number | PositiveUniversalMeasure;
+    readonly rule: (typeof HeightRule)[keyof typeof HeightRule];
+  };
+  readonly cellSpacing?: ITableCellSpacingProperties;
+}
+type ITableRowPropertiesOptions = ITableRowPropertiesOptionsBase & {
+  readonly insertion?: IChangedAttributesProperties;
+  readonly deletion?: IChangedAttributesProperties;
+  readonly revision?: ITableRowPropertiesChangeOptions;
+  readonly includeIfEmpty?: boolean;
+};
+type ITableRowPropertiesChangeOptions = ITableRowPropertiesOptionsBase & IChangedAttributesProperties;
+declare class TableRowProperties extends IgnoreIfEmptyXmlComponent {
+  constructor(options: ITableRowPropertiesOptions);
+}
+declare class TableRowPropertiesChange extends XmlComponent {
+  constructor(options: ITableRowPropertiesChangeOptions);
+}
+//#endregion
+//#region src/file/table/table-row/table-row.d.ts
+type ITableRowOptions = {
+  readonly children: readonly TableCell[];
+} & ITableRowPropertiesOptions;
+declare class TableRow extends XmlComponent {
+  private readonly options;
+  constructor(options: ITableRowOptions);
+  get CellCount(): number;
+  get cells(): readonly TableCell[];
+  addCellToIndex(cell: TableCell, index: number): void;
+  addCellToColumnIndex(cell: TableCell, columnIndex: number): void;
+  rootIndexToColumnIndex(rootIndex: number): number;
+  columnIndexToRootIndex(columnIndex: number, allowEndNewCell?: boolean): number;
+}
+//#endregion
+//#region src/file/table/table.d.ts
+interface ITableOptions {
+  readonly rows: readonly TableRow[];
+  readonly width?: ITableWidthProperties;
+  readonly columnWidths?: readonly number[];
+  readonly columnWidthsRevision?: ITableGridChangeOptions;
+  readonly margins?: ITableCellMarginOptions;
+  readonly indent?: ITableWidthProperties;
+  readonly float?: ITableFloatOptions;
+  readonly layout?: (typeof TableLayoutType)[keyof typeof TableLayoutType];
+  readonly style?: string;
+  readonly borders?: ITableBordersOptions;
+  readonly alignment?: (typeof AlignmentType)[keyof typeof AlignmentType];
+  readonly visuallyRightToLeft?: boolean;
+  readonly tableLook?: ITableLookOptions;
+  readonly cellSpacing?: ITableCellSpacingProperties;
+  readonly revision?: ITablePropertiesChangeOptions;
+}
+declare class Table extends FileChild {
+  constructor({
+    rows,
+    width,
+    columnWidths,
+    columnWidthsRevision,
+    margins,
+    indent,
+    float,
+    layout,
+    style,
+    borders,
+    alignment,
+    visuallyRightToLeft,
+    tableLook,
+    cellSpacing,
+    revision
+  }: ITableOptions);
+}
+//#endregion
+//#region src/file/table-of-contents/table-of-contents.d.ts
+interface ToCEntry {
+  readonly title: string;
+  readonly level: number;
+  readonly page?: number;
+  readonly href?: string;
+}
+declare class TableOfContents extends FileChild {
+  constructor(alias?: string, {
+    contentChildren,
+    cachedEntries,
+    beginDirty,
+    ...properties
+  }?: ITableOfContentsOptions & {
+    readonly contentChildren?: readonly (XmlComponent | string)[];
+    readonly cachedEntries?: readonly ToCEntry[];
+    readonly beginDirty?: boolean;
+  });
+  private getTabStopsForLevel;
+  private buildCachedContentRun;
+  private buildCachedContentParagraphChild;
+}
+//#endregion
+//#region src/file/footer/footer.d.ts
+declare class Footer$1 extends InitializableXmlComponent {
+  private readonly refId;
+  constructor(referenceNumber: number, initContent?: XmlComponent);
+  get ReferenceId(): number;
+  add(item: Paragraph | Table): void;
+}
+//#endregion
+//#region src/file/footer-wrapper.d.ts
+interface IDocumentFooter {
+  readonly footer: FooterWrapper;
+  readonly type: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType];
+}
+declare class FooterWrapper implements IViewWrapper {
+  private readonly media;
+  private readonly footer;
+  private readonly relationships;
+  constructor(media: Media, referenceId: number, initContent?: XmlComponent);
+  add(item: Paragraph | Table): void;
+  addChildElement(childElement: XmlComponent): void;
+  get View(): Footer$1;
+  get Relationships(): Relationships;
+  get Media(): Media;
+}
+//#endregion
+//#region src/file/header/header.d.ts
+declare class Header$1 extends InitializableXmlComponent {
+  private readonly refId;
+  constructor(referenceNumber: number, initContent?: XmlComponent);
+  get ReferenceId(): number;
+  add(item: Paragraph | Table): void;
+}
+//#endregion
+//#region src/file/header-wrapper.d.ts
+interface IDocumentHeader {
+  readonly header: HeaderWrapper;
+  readonly type: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType];
+}
+declare class HeaderWrapper implements IViewWrapper {
+  private readonly media;
+  private readonly header;
+  private readonly relationships;
+  constructor(media: Media, referenceId: number, initContent?: XmlComponent);
+  add(item: Paragraph | Table): HeaderWrapper;
+  addChildElement(childElement: XmlComponent | string): void;
+  get View(): Header$1;
+  get Relationships(): Relationships;
+  get Media(): Media;
+}
+//#endregion
+//#region src/file/document/body/section-properties/properties/column.d.ts
+interface IColumnAttributes {
+  readonly width: number | PositiveUniversalMeasure;
+  readonly space?: number | PositiveUniversalMeasure;
+}
+declare class Column extends XmlComponent {
+  constructor(options: IColumnAttributes);
+}
+//#endregion
+//#region src/file/document/body/section-properties/properties/columns.d.ts
+interface IColumnsAttributes {
+  readonly space?: number | PositiveUniversalMeasure;
+  readonly count?: number;
+  readonly separate?: boolean;
+  readonly equalWidth?: boolean;
+  readonly children?: readonly Column[];
+}
+declare const createColumns: ({
+  space,
+  count,
+  separate,
+  equalWidth,
+  children
+}: IColumnsAttributes) => XmlComponent;
+//#endregion
+//#region src/file/document/body/section-properties/properties/doc-grid.d.ts
+declare const DocumentGridType: {
+  readonly DEFAULT: "default";
+  readonly LINES: "lines";
+  readonly LINES_AND_CHARS: "linesAndChars";
+  readonly SNAP_TO_CHARS: "snapToChars";
+};
+interface IDocGridAttributesProperties {
+  readonly type?: (typeof DocumentGridType)[keyof typeof DocumentGridType];
+  readonly linePitch: number;
+  readonly charSpace?: number;
+}
+declare const createDocumentGrid: ({
+  type,
+  linePitch,
+  charSpace
+}: IDocGridAttributesProperties) => XmlComponent;
+//#endregion
+//#region src/file/document/body/section-properties/properties/line-number.d.ts
+declare const LineNumberRestartFormat: {
+  readonly NEW_PAGE: "newPage";
+  readonly NEW_SECTION: "newSection";
+  readonly CONTINUOUS: "continuous";
+};
+interface ILineNumberAttributes {
+  readonly countBy?: number;
+  readonly start?: number;
+  readonly restart?: (typeof LineNumberRestartFormat)[keyof typeof LineNumberRestartFormat];
+  readonly distance?: number | PositiveUniversalMeasure;
+}
+declare const createLineNumberType: ({
+  countBy,
+  start,
+  restart,
+  distance
+}: ILineNumberAttributes) => XmlComponent;
+//#endregion
+//#region src/file/document/body/section-properties/properties/page-borders.d.ts
+declare const PageBorderDisplay: {
+  readonly ALL_PAGES: "allPages";
+  readonly FIRST_PAGE: "firstPage";
+  readonly NOT_FIRST_PAGE: "notFirstPage";
+};
+declare const PageBorderOffsetFrom: {
+  readonly PAGE: "page";
+  readonly TEXT: "text";
+};
+declare const PageBorderZOrder: {
+  readonly BACK: "back";
+  readonly FRONT: "front";
+};
+interface IPageBorderAttributes {
+  readonly display?: (typeof PageBorderDisplay)[keyof typeof PageBorderDisplay];
+  readonly offsetFrom?: (typeof PageBorderOffsetFrom)[keyof typeof PageBorderOffsetFrom];
+  readonly zOrder?: (typeof PageBorderZOrder)[keyof typeof PageBorderZOrder];
+}
+interface IPageBordersOptions {
+  readonly pageBorders?: IPageBorderAttributes;
+  readonly pageBorderTop?: IBorderOptions;
+  readonly pageBorderRight?: IBorderOptions;
+  readonly pageBorderBottom?: IBorderOptions;
+  readonly pageBorderLeft?: IBorderOptions;
+}
+declare class PageBorders extends IgnoreIfEmptyXmlComponent {
+  constructor(options?: IPageBordersOptions);
+}
+//#endregion
+//#region src/file/document/body/section-properties/properties/page-margin.d.ts
+interface IPageMarginAttributes {
+  readonly top?: number | UniversalMeasure;
+  readonly right?: number | PositiveUniversalMeasure;
+  readonly bottom?: number | UniversalMeasure;
+  readonly left?: number | PositiveUniversalMeasure;
+  readonly header?: number | PositiveUniversalMeasure;
+  readonly footer?: number | PositiveUniversalMeasure;
+  readonly gutter?: number | PositiveUniversalMeasure;
+}
+declare const createPageMargin: (top: number | UniversalMeasure, right: number | PositiveUniversalMeasure, bottom: number | UniversalMeasure, left: number | PositiveUniversalMeasure, header: number | PositiveUniversalMeasure, footer: number | PositiveUniversalMeasure, gutter: number | PositiveUniversalMeasure) => XmlComponent;
+//#endregion
+//#region src/file/shared/number-format.d.ts
+declare const NumberFormat: {
+  readonly AIUEO: "aiueo";
+  readonly AIUEO_FULL_WIDTH: "aiueoFullWidth";
+  readonly ARABIC_ABJAD: "arabicAbjad";
+  readonly ARABIC_ALPHA: "arabicAlpha";
+  readonly BAHT_TEXT: "bahtText";
+  readonly BULLET: "bullet";
+  readonly CARDINAL_TEXT: "cardinalText";
+  readonly CHICAGO: "chicago";
+  readonly CHINESE_COUNTING: "chineseCounting";
+  readonly CHINESE_COUNTING_TEN_THOUSAND: "chineseCountingThousand";
+  readonly CHINESE_LEGAL_SIMPLIFIED: "chineseLegalSimplified";
+  readonly CHOSUNG: "chosung";
+  readonly DECIMAL: "decimal";
+  readonly DECIMAL_ENCLOSED_CIRCLE: "decimalEnclosedCircle";
+  readonly DECIMAL_ENCLOSED_CIRCLE_CHINESE: "decimalEnclosedCircleChinese";
+  readonly DECIMAL_ENCLOSED_FULL_STOP: "decimalEnclosedFullstop";
+  readonly DECIMAL_ENCLOSED_PAREN: "decimalEnclosedParen";
+  readonly DECIMAL_FULL_WIDTH: "decimalFullWidth";
+  readonly DECIMAL_FULL_WIDTH_2: "decimalFullWidth2";
+  readonly DECIMAL_HALF_WIDTH: "decimalHalfWidth";
+  readonly DECIMAL_ZERO: "decimalZero";
+  readonly DOLLAR_TEXT: "dollarText";
+  readonly GANADA: "ganada";
+  readonly HEBREW_1: "hebrew1";
+  readonly HEBREW_2: "hebrew2";
+  readonly HEX: "hex";
+  readonly HINDI_CONSONANTS: "hindiConsonants";
+  readonly HINDI_COUNTING: "hindiCounting";
+  readonly HINDI_NUMBERS: "hindiNumbers";
+  readonly HINDI_VOWELS: "hindiVowels";
+  readonly IDEOGRAPH_DIGITAL: "ideographDigital";
+  readonly IDEOGRAPH_ENCLOSED_CIRCLE: "ideographEnclosedCircle";
+  readonly IDEOGRAPH_LEGAL_TRADITIONAL: "ideographLegalTraditional";
+  readonly IDEOGRAPH_TRADITIONAL: "ideographTraditional";
+  readonly IDEOGRAPH_ZODIAC: "ideographZodiac";
+  readonly IDEOGRAPH_ZODIAC_TRADITIONAL: "ideographZodiacTraditional";
+  readonly IROHA: "iroha";
+  readonly IROHA_FULL_WIDTH: "irohaFullWidth";
+  readonly JAPANESE_COUNTING: "japaneseCounting";
+  readonly JAPANESE_DIGITAL_TEN_THOUSAND: "japaneseDigitalTenThousand";
+  readonly JAPANESE_LEGAL: "japaneseLegal";
+  readonly KOREAN_COUNTING: "koreanCounting";
+  readonly KOREAN_DIGITAL: "koreanDigital";
+  readonly KOREAN_DIGITAL_2: "koreanDigital2";
+  readonly KOREAN_LEGAL: "koreanLegal";
+  readonly LOWER_LETTER: "lowerLetter";
+  readonly LOWER_ROMAN: "lowerRoman";
+  readonly NONE: "none";
+  readonly NUMBER_IN_DASH: "numberInDash";
+  readonly ORDINAL: "ordinal";
+  readonly ORDINAL_TEXT: "ordinalText";
+  readonly RUSSIAN_LOWER: "russianLower";
+  readonly RUSSIAN_UPPER: "russianUpper";
+  readonly TAIWANESE_COUNTING: "taiwaneseCounting";
+  readonly TAIWANESE_COUNTING_THOUSAND: "taiwaneseCountingThousand";
+  readonly TAIWANESE_DIGITAL: "taiwaneseDigital";
+  readonly THAI_COUNTING: "thaiCounting";
+  readonly THAI_LETTERS: "thaiLetters";
+  readonly THAI_NUMBERS: "thaiNumbers";
+  readonly UPPER_LETTER: "upperLetter";
+  readonly UPPER_ROMAN: "upperRoman";
+  readonly VIETNAMESE_COUNTING: "vietnameseCounting";
+};
+//#endregion
+//#region src/file/document/body/section-properties/properties/page-number.d.ts
+declare const PageNumberSeparator: {
+  readonly HYPHEN: "hyphen";
+  readonly PERIOD: "period";
+  readonly COLON: "colon";
+  readonly EM_DASH: "emDash";
+  readonly EN_DASH: "endash";
+};
+interface IPageNumberTypeAttributes {
+  readonly start?: number;
+  readonly formatType?: (typeof NumberFormat)[keyof typeof NumberFormat];
+  readonly separator?: (typeof PageNumberSeparator)[keyof typeof PageNumberSeparator];
+}
+declare const createPageNumberType: ({
+  start,
+  formatType,
+  separator
+}: IPageNumberTypeAttributes) => XmlComponent;
+//#endregion
+//#region src/file/document/body/section-properties/properties/page-size.d.ts
+declare const PageOrientation: {
+  readonly PORTRAIT: "portrait";
+  readonly LANDSCAPE: "landscape";
+};
+interface IPageSizeAttributes {
+  readonly width: number | PositiveUniversalMeasure;
+  readonly height: number | PositiveUniversalMeasure;
+  readonly orientation?: (typeof PageOrientation)[keyof typeof PageOrientation];
+  readonly code?: number;
+}
+declare const createPageSize: ({
+  width,
+  height,
+  orientation,
+  code
+}: IPageSizeAttributes) => XmlComponent;
+//#endregion
+//#region src/file/document/body/section-properties/properties/page-text-direction.d.ts
+declare const PageTextDirectionType: {
+  readonly LEFT_TO_RIGHT_TOP_TO_BOTTOM: "lrTb";
+  readonly TOP_TO_BOTTOM_RIGHT_TO_LEFT: "tbRl";
+};
+declare class PageTextDirection extends XmlComponent {
+  constructor(value: (typeof PageTextDirectionType)[keyof typeof PageTextDirectionType]);
+}
+//#endregion
+//#region src/file/document/body/section-properties/properties/section-type.d.ts
+declare const SectionType: {
+  readonly NEXT_PAGE: "nextPage";
+  readonly NEXT_COLUMN: "nextColumn";
+  readonly CONTINUOUS: "continuous";
+  readonly EVEN_PAGE: "evenPage";
+  readonly ODD_PAGE: "oddPage";
+};
+declare const createSectionType: (value: (typeof SectionType)[keyof typeof SectionType]) => XmlComponent;
+//#endregion
+//#region src/file/document/body/section-properties/section-properties.d.ts
+interface IHeaderFooterGroup<T> {
+  readonly default?: T;
+  readonly first?: T;
+  readonly even?: T;
+}
+interface ISectionPropertiesOptionsBase {
+  readonly page?: {
+    readonly size?: Partial<IPageSizeAttributes>;
+    readonly margin?: IPageMarginAttributes;
+    readonly pageNumbers?: IPageNumberTypeAttributes;
+    readonly borders?: IPageBordersOptions;
+    readonly textDirection?: (typeof PageTextDirectionType)[keyof typeof PageTextDirectionType];
+  };
+  readonly grid?: Partial<IDocGridAttributesProperties>;
+  readonly headerWrapperGroup?: IHeaderFooterGroup<HeaderWrapper>;
+  readonly footerWrapperGroup?: IHeaderFooterGroup<FooterWrapper>;
+  readonly lineNumbers?: ILineNumberAttributes;
+  readonly titlePage?: boolean;
+  readonly verticalAlign?: SectionVerticalAlign;
+  readonly column?: IColumnsAttributes;
+  readonly type?: (typeof SectionType)[keyof typeof SectionType];
+}
+type ISectionPropertiesChangeOptions = IChangedAttributesProperties & ISectionPropertiesOptionsBase;
+type ISectionPropertiesOptions = {
+  readonly revision?: ISectionPropertiesChangeOptions;
+} & ISectionPropertiesOptionsBase;
+declare const sectionMarginDefaults: {
+  TOP: number;
+  RIGHT: number;
+  BOTTOM: number;
+  LEFT: number;
+  HEADER: number;
+  FOOTER: number;
+  GUTTER: number;
+};
+declare const sectionPageSizeDefaults: {
+  WIDTH: number;
+  HEIGHT: number;
+  ORIENTATION: "portrait";
+};
+declare class SectionProperties extends XmlComponent {
+  constructor({
+    page: {
+      size: {
+        width,
+        height,
+        orientation
+      },
+      margin: {
+        top,
+        right,
+        bottom,
+        left,
+        header,
+        footer,
+        gutter
+      },
+      pageNumbers,
+      borders,
+      textDirection
+    },
+    grid: {
+      linePitch,
+      charSpace,
+      type: gridType
+    },
+    headerWrapperGroup,
+    footerWrapperGroup,
+    lineNumbers,
+    titlePage,
+    verticalAlign,
+    column,
+    type,
+    revision
+  }?: ISectionPropertiesOptions);
+  private addHeaderFooterGroup;
+}
+declare class SectionPropertiesChange extends XmlComponent {
+  constructor(options: ISectionPropertiesChangeOptions);
+}
+//#endregion
+//#region src/file/document/body/body.d.ts
+declare class Body extends XmlComponent {
+  private readonly sections;
+  constructor();
+  addSection(options: ISectionPropertiesOptions): void;
+  prepForXml(context: IContext): IXmlableObject | undefined;
+  push(component: XmlComponent): void;
+  private createSectionParagraph;
+}
+//#endregion
+//#region src/file/document/body/section-properties/properties/header-footer-reference.d.ts
+declare const HeaderFooterReferenceType: {
+  readonly DEFAULT: "default";
+  readonly FIRST: "first";
+  readonly EVEN: "even";
+};
+interface IHeaderFooterOptions {
+  readonly type?: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType];
+  readonly id?: number;
+}
+declare const HeaderFooterType: {
+  readonly FOOTER: "w:footerReference";
+  readonly HEADER: "w:headerReference";
+};
+declare const createHeaderFooterReference: (type: (typeof HeaderFooterType)[keyof typeof HeaderFooterType], options: IHeaderFooterOptions) => XmlComponent;
+//#endregion
+//#region src/file/document/document-background/document-background.d.ts
+declare class DocumentBackgroundAttributes extends XmlAttributeComponent<{
+  readonly color?: string;
+  readonly themeColor?: string;
+  readonly themeShade?: string;
+  readonly themeTint?: string;
+}> {
+  protected readonly xmlKeys: {
+    color: string;
+    themeColor: string;
+    themeShade: string;
+    themeTint: string;
+  };
+}
+interface IDocumentBackgroundOptions {
+  readonly color?: string;
+  readonly themeColor?: string;
+  readonly themeShade?: string;
+  readonly themeTint?: string;
+}
+declare class DocumentBackground extends XmlComponent {
+  constructor(options: IDocumentBackgroundOptions);
+}
+//#endregion
+//#region src/file/document/document.d.ts
+interface IDocumentOptions {
+  readonly background?: IDocumentBackgroundOptions;
+}
+declare class Document extends XmlComponent {
+  private readonly body;
+  constructor(options: IDocumentOptions);
+  add(item: Paragraph | Table | TableOfContents | ConcreteHyperlink): Document;
+  get Body(): Body;
+}
+//#endregion
+//#region src/file/document/document-attributes.d.ts
+declare const DocumentAttributeNamespaces: {
+  aink: string;
+  am3d: string;
+  cp: string;
+  cx: string;
+  cx1: string;
+  cx2: string;
+  cx3: string;
+  cx4: string;
+  cx5: string;
+  cx6: string;
+  cx7: string;
+  cx8: string;
+  dc: string;
+  dcmitype: string;
+  dcterms: string;
+  m: string;
+  mc: string;
+  o: string;
+  r: string;
+  v: string;
+  w: string;
+  w10: string;
+  w14: string;
+  w15: string;
+  w16: string;
+  w16cex: string;
+  w16cid: string;
+  w16sdtdh: string;
+  w16se: string;
+  wne: string;
+  wp: string;
+  wp14: string;
+  wpc: string;
+  wpg: string;
+  wpi: string;
+  wps: string;
+  xsi: string;
+};
+type DocumentAttributeNamespace = keyof typeof DocumentAttributeNamespaces;
+type IDocumentAttributesProperties = Partial<Record<DocumentAttributeNamespace, string>> & {
+  readonly Ignorable?: string;
+};
+declare class DocumentAttributes extends XmlAttributeComponent<IDocumentAttributesProperties> {
+  protected readonly xmlKeys: AttributeMap<IDocumentAttributesProperties>;
+  constructor(ns: readonly DocumentAttributeNamespace[], Ignorable?: string);
+}
+//#endregion
+//#region src/file/endnotes/endnotes.d.ts
+declare class Endnotes extends XmlComponent {
+  constructor();
+  createEndnote(id: number, paragraph: readonly Paragraph[]): void;
+}
+//#endregion
+//#region src/file/endnotes/endnote/run/reference-run.d.ts
+declare class EndnoteReferenceRunAttributes extends XmlAttributeComponent<{
+  readonly id: number;
+}> {
+  protected readonly xmlKeys: {
+    id: string;
+  };
+}
+declare class EndnoteIdReference extends XmlComponent {
+  constructor(id: number);
+}
+declare class EndnoteReferenceRun extends Run {
+  constructor(id: number);
+}
+//#endregion
+//#region src/file/footnotes/footnotes.d.ts
+declare class FootNotes extends XmlComponent {
+  constructor();
+  createFootNote(id: number, paragraph: readonly Paragraph[]): void;
+}
+//#endregion
+//#region src/file/document-wrapper.d.ts
+interface IViewWrapper {
+  readonly View: Document | Footer$1 | Header$1 | FootNotes | Endnotes | XmlComponent;
+  readonly Relationships: Relationships;
+}
+declare class DocumentWrapper implements IViewWrapper {
+  private readonly document;
+  private readonly relationships;
+  constructor(options: IDocumentOptions);
+  get View(): Document;
+  get Relationships(): Relationships;
+}
+//#endregion
+//#region src/file/app-properties/app-properties.d.ts
+declare class AppProperties extends XmlComponent {
+  constructor();
+}
+//#endregion
+//#region src/file/content-types/content-types.d.ts
+declare class ContentTypes extends XmlComponent {
+  constructor();
+  addFooter(index: number): void;
+  addHeader(index: number): void;
+}
+//#endregion
+//#region src/file/fonts/font.d.ts
+declare const CharacterSet: {
+  readonly ANSI: "00";
+  readonly ARABIC: "B2";
+  readonly BALTIC: "BA";
+  readonly CHINESEBIG5: "88";
+  readonly DEFAULT: "01";
+  readonly EASTEUROPE: "EE";
+  readonly GB_2312: "86";
+  readonly GREEK: "A1";
+  readonly HANGUL: "81";
+  readonly HEBREW: "B1";
+  readonly JIS: "80";
+  readonly JOHAB: "82";
+  readonly MAC: "4D";
+  readonly OEM: "FF";
+  readonly RUSSIAN: "CC";
+  readonly SYMBOL: "02";
+  readonly THAI: "DE";
+  readonly TURKISH: "A2";
+  readonly VIETNAMESE: "A3";
+};
+//#endregion
+//#region src/file/fonts/font-wrapper.d.ts
+type FontOptionsWithKey = FontOptions & {
+  readonly fontKey: string;
+};
+declare class FontWrapper implements IViewWrapper {
+  readonly options: readonly FontOptions[];
+  private readonly fontTable;
+  private readonly relationships;
+  readonly fontOptionsWithKey: readonly FontOptionsWithKey[];
+  constructor(options: readonly FontOptions[]);
+  get View(): XmlComponent;
+  get Relationships(): Relationships;
+}
+//#endregion
+//#region src/file/fonts/font-table.d.ts
+interface FontOptions {
+  readonly name: string;
+  readonly data: Buffer;
+  readonly characterSet?: (typeof CharacterSet)[keyof typeof CharacterSet];
+}
+//#endregion
+//#region src/file/settings/compatibility.d.ts
+interface ICompatibilityOptions {
+  readonly version?: number;
+  readonly useSingleBorderforContiguousCells?: boolean;
+  readonly wordPerfectJustification?: boolean;
+  readonly noTabStopForHangingIndent?: boolean;
+  readonly noLeading?: boolean;
+  readonly spaceForUnderline?: boolean;
+  readonly noColumnBalance?: boolean;
+  readonly balanceSingleByteDoubleByteWidth?: boolean;
+  readonly noExtraLineSpacing?: boolean;
+  readonly doNotLeaveBackslashAlone?: boolean;
+  readonly underlineTrailingSpaces?: boolean;
+  readonly doNotExpandShiftReturn?: boolean;
+  readonly spacingInWholePoints?: boolean;
+  readonly lineWrapLikeWord6?: boolean;
+  readonly printBodyTextBeforeHeader?: boolean;
+  readonly printColorsBlack?: boolean;
+  readonly spaceWidth?: boolean;
+  readonly showBreaksInFrames?: boolean;
+  readonly subFontBySize?: boolean;
+  readonly suppressBottomSpacing?: boolean;
+  readonly suppressTopSpacing?: boolean;
+  readonly suppressSpacingAtTopOfPage?: boolean;
+  readonly suppressTopSpacingWP?: boolean;
+  readonly suppressSpBfAfterPgBrk?: boolean;
+  readonly swapBordersFacingPages?: boolean;
+  readonly convertMailMergeEsc?: boolean;
+  readonly truncateFontHeightsLikeWP6?: boolean;
+  readonly macWordSmallCaps?: boolean;
+  readonly usePrinterMetrics?: boolean;
+  readonly doNotSuppressParagraphBorders?: boolean;
+  readonly wrapTrailSpaces?: boolean;
+  readonly footnoteLayoutLikeWW8?: boolean;
+  readonly shapeLayoutLikeWW8?: boolean;
+  readonly alignTablesRowByRow?: boolean;
+  readonly forgetLastTabAlignment?: boolean;
+  readonly adjustLineHeightInTable?: boolean;
+  readonly autoSpaceLikeWord95?: boolean;
+  readonly noSpaceRaiseLower?: boolean;
+  readonly doNotUseHTMLParagraphAutoSpacing?: boolean;
+  readonly layoutRawTableWidth?: boolean;
+  readonly layoutTableRowsApart?: boolean;
+  readonly useWord97LineBreakRules?: boolean;
+  readonly doNotBreakWrappedTables?: boolean;
+  readonly doNotSnapToGridInCell?: boolean;
+  readonly selectFieldWithFirstOrLastCharacter?: boolean;
+  readonly applyBreakingRules?: boolean;
+  readonly doNotWrapTextWithPunctuation?: boolean;
+  readonly doNotUseEastAsianBreakRules?: boolean;
+  readonly useWord2002TableStyleRules?: boolean;
+  readonly growAutofit?: boolean;
+  readonly useFELayout?: boolean;
+  readonly useNormalStyleForList?: boolean;
+  readonly doNotUseIndentAsNumberingTabStop?: boolean;
+  readonly useAlternateEastAsianLineBreakRules?: boolean;
+  readonly allowSpaceOfSameStyleInTable?: boolean;
+  readonly doNotSuppressIndentation?: boolean;
+  readonly doNotAutofitConstrainedTables?: boolean;
+  readonly autofitToFirstFixedWidthCell?: boolean;
+  readonly underlineTabInNumberingList?: boolean;
+  readonly displayHangulFixedWidth?: boolean;
+  readonly splitPgBreakAndParaMark?: boolean;
+  readonly doNotVerticallyAlignCellWithSp?: boolean;
+  readonly doNotBreakConstrainedForcedTable?: boolean;
+  readonly ignoreVerticalAlignmentInTextboxes?: boolean;
+  readonly useAnsiKerningPairs?: boolean;
+  readonly cachedColumnBalance?: boolean;
+}
+//#endregion
+//#region src/file/settings/settings.d.ts
+interface ISettingsOptions {
+  readonly compatibilityModeVersion?: number;
+  readonly evenAndOddHeaders?: boolean;
+  readonly trackRevisions?: boolean;
+  readonly updateFields?: boolean;
+  readonly compatibility?: ICompatibilityOptions;
+  readonly defaultTabStop?: number;
+  readonly hyphenation?: IHyphenationOptions;
+}
+interface IHyphenationOptions {
+  readonly autoHyphenation?: boolean;
+  readonly hyphenationZone?: number;
+  readonly consecutiveHyphenLimit?: number;
+  readonly doNotHyphenateCaps?: boolean;
+}
+declare class Settings extends XmlComponent {
+  constructor(options: ISettingsOptions);
+}
+//#endregion
+//#region src/file/custom-properties/custom-property.d.ts
+interface ICustomPropertyOptions {
+  readonly name: string;
+  readonly value: string;
+}
+//#endregion
+//#region src/file/custom-properties/custom-properties.d.ts
+declare class CustomProperties extends XmlComponent {
+  private nextId;
+  private readonly properties;
+  constructor(properties: readonly ICustomPropertyOptions[]);
+  prepForXml(context: IContext): IXmlableObject | undefined;
+  addCustomProperty(property: ICustomPropertyOptions): void;
+}
+//#endregion
+//#region src/file/paragraph/formatting/border.d.ts
+interface IBordersOptions {
+  readonly top?: IBorderOptions;
+  readonly bottom?: IBorderOptions;
+  readonly left?: IBorderOptions;
+  readonly right?: IBorderOptions;
+  readonly between?: IBorderOptions;
+}
+declare class Border extends IgnoreIfEmptyXmlComponent {
+  constructor(options: IBordersOptions);
+}
+declare class ThematicBreak extends XmlComponent {
+  constructor();
+}
+//#endregion
+//#region src/file/paragraph/formatting/indent.d.ts
+interface IIndentAttributesProperties {
+  readonly start?: number | UniversalMeasure;
+  readonly end?: number | UniversalMeasure;
+  readonly left?: number | UniversalMeasure;
+  readonly right?: number | UniversalMeasure;
+  readonly hanging?: number | PositiveUniversalMeasure;
+  readonly firstLine?: number | PositiveUniversalMeasure;
+}
+declare const createIndent: ({
+  start,
+  end,
+  left,
+  right,
+  hanging,
+  firstLine
+}: IIndentAttributesProperties) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/formatting/spacing.d.ts
+declare const LineRuleType: {
+  readonly AT_LEAST: "atLeast";
+  readonly EXACTLY: "exactly";
+  readonly EXACT: "exact";
+  readonly AUTO: "auto";
+};
+interface ISpacingProperties {
+  readonly after?: number;
+  readonly before?: number;
+  readonly line?: number;
+  readonly lineRule?: (typeof LineRuleType)[keyof typeof LineRuleType];
+  readonly beforeAutoSpacing?: boolean;
+  readonly afterAutoSpacing?: boolean;
+}
+declare const createSpacing: ({
+  after,
+  before,
+  line,
+  lineRule,
+  beforeAutoSpacing,
+  afterAutoSpacing
+}: ISpacingProperties) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/formatting/style.d.ts
+declare const HeadingLevel: {
+  readonly HEADING_1: "Heading1";
+  readonly HEADING_2: "Heading2";
+  readonly HEADING_3: "Heading3";
+  readonly HEADING_4: "Heading4";
+  readonly HEADING_5: "Heading5";
+  readonly HEADING_6: "Heading6";
+  readonly TITLE: "Title";
+};
+declare const createParagraphStyle: (styleId: string) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/formatting/tab-stop.d.ts
+interface TabStopDefinition {
+  readonly type: (typeof TabStopType)[keyof typeof TabStopType];
+  readonly position: number | (typeof TabStopPosition)[keyof typeof TabStopPosition];
+  readonly leader?: (typeof LeaderType)[keyof typeof LeaderType];
+}
+declare const TabStopType: {
+  readonly LEFT: "left";
+  readonly RIGHT: "right";
+  readonly CENTER: "center";
+  readonly BAR: "bar";
+  readonly CLEAR: "clear";
+  readonly DECIMAL: "decimal";
+  readonly END: "end";
+  readonly NUM: "num";
+  readonly START: "start";
+};
+declare const LeaderType: {
+  readonly DOT: "dot";
+  readonly HYPHEN: "hyphen";
+  readonly MIDDLE_DOT: "middleDot";
+  readonly NONE: "none";
+  readonly UNDERSCORE: "underscore";
+};
+declare const TabStopPosition: {
+  readonly MAX: 9026;
+};
+declare const createTabStopItem: ({
+  type,
+  position,
+  leader
+}: TabStopDefinition) => XmlComponent;
+declare const createTabStop: (tabDefinitions: readonly TabStopDefinition[]) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/frame/frame-properties.d.ts
+declare const DropCapType: {
+  readonly NONE: "none";
+  readonly DROP: "drop";
+  readonly MARGIN: "margin";
+};
+declare const FrameAnchorType: {
+  readonly MARGIN: "margin";
+  readonly PAGE: "page";
+  readonly TEXT: "text";
+};
+declare const FrameWrap: {
+  readonly AROUND: "around";
+  readonly AUTO: "auto";
+  readonly NONE: "none";
+  readonly NOT_BESIDE: "notBeside";
+  readonly THROUGH: "through";
+  readonly TIGHT: "tight";
+};
+interface IBaseFrameOptions {
+  readonly anchorLock?: boolean;
+  readonly dropCap?: (typeof DropCapType)[keyof typeof DropCapType];
+  readonly width: number;
+  readonly height: number;
+  readonly wrap?: (typeof FrameWrap)[keyof typeof FrameWrap];
+  readonly lines?: number;
+  readonly anchor: {
+    readonly horizontal: (typeof FrameAnchorType)[keyof typeof FrameAnchorType];
+    readonly vertical: (typeof FrameAnchorType)[keyof typeof FrameAnchorType];
+  };
+  readonly space?: {
+    readonly horizontal: number;
+    readonly vertical: number;
+  };
+  readonly rule?: (typeof HeightRule)[keyof typeof HeightRule];
+}
+type IXYFrameOptions = {
+  readonly type: "absolute";
+  readonly position: {
+    readonly x: number;
+    readonly y: number;
+  };
+} & IBaseFrameOptions;
+type IAlignmentFrameOptions = {
+  readonly type: "alignment";
+  readonly alignment: {
+    readonly x: (typeof HorizontalPositionAlign)[keyof typeof HorizontalPositionAlign];
+    readonly y: (typeof VerticalPositionAlign)[keyof typeof VerticalPositionAlign];
+  };
+} & IBaseFrameOptions;
+type IFrameOptions = IXYFrameOptions | IAlignmentFrameOptions;
+declare const createFrameProperties: (options: IFrameOptions) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/properties.d.ts
+interface ILevelParagraphStylePropertiesOptions {
+  readonly alignment?: (typeof AlignmentType)[keyof typeof AlignmentType];
+  readonly thematicBreak?: boolean;
+  readonly contextualSpacing?: boolean;
+  readonly rightTabStop?: number;
+  readonly leftTabStop?: number;
+  readonly indent?: IIndentAttributesProperties;
+  readonly spacing?: ISpacingProperties;
+  readonly keepNext?: boolean;
+  readonly keepLines?: boolean;
+  readonly outlineLevel?: number;
+}
+type IParagraphStylePropertiesOptions = {
+  readonly border?: IBordersOptions;
+  readonly shading?: IShadingAttributesProperties;
+  readonly numbering?: {
+    readonly reference: string;
+    readonly level: number;
+    readonly instance?: number;
+    readonly custom?: boolean;
+  } | false;
+} & ILevelParagraphStylePropertiesOptions;
+type IParagraphPropertiesOptionsBase = {
+  readonly heading?: (typeof HeadingLevel)[keyof typeof HeadingLevel];
+  readonly bidirectional?: boolean;
+  readonly pageBreakBefore?: boolean;
+  readonly tabStops?: readonly TabStopDefinition[];
+  readonly style?: string;
+  readonly bullet?: {
+    readonly level: number;
+  };
+  readonly widowControl?: boolean;
+  readonly frame?: IFrameOptions;
+  readonly suppressLineNumbers?: boolean;
+  readonly wordWrap?: boolean;
+  readonly overflowPunctuation?: boolean;
+  readonly scale?: number;
+  readonly autoSpaceEastAsianText?: boolean;
+  readonly run?: IParagraphRunOptions;
+} & IParagraphStylePropertiesOptions;
+type IParagraphPropertiesChangeOptions = IChangedAttributesProperties & IParagraphPropertiesOptionsBase;
+type IParagraphPropertiesOptions = {
+  readonly revision?: IParagraphPropertiesChangeOptions;
+  readonly includeIfEmpty?: boolean;
+} & IParagraphPropertiesOptionsBase;
+declare class ParagraphProperties extends IgnoreIfEmptyXmlComponent {
+  private readonly numberingReferences;
+  constructor(options?: IParagraphPropertiesOptions);
+  push(item: XmlComponent): void;
+  prepForXml(context: IContext): IXmlableObject | undefined;
+}
+declare class ParagraphPropertiesChange extends XmlComponent {
+  constructor(options: IParagraphPropertiesChangeOptions);
+}
+//#endregion
+//#region src/file/numbering/level.d.ts
+declare const LevelFormat: {
+  readonly DECIMAL: "decimal";
+  readonly UPPER_ROMAN: "upperRoman";
+  readonly LOWER_ROMAN: "lowerRoman";
+  readonly UPPER_LETTER: "upperLetter";
+  readonly LOWER_LETTER: "lowerLetter";
+  readonly ORDINAL: "ordinal";
+  readonly CARDINAL_TEXT: "cardinalText";
+  readonly ORDINAL_TEXT: "ordinalText";
+  readonly HEX: "hex";
+  readonly CHICAGO: "chicago";
+  readonly IDEOGRAPH__DIGITAL: "ideographDigital";
+  readonly JAPANESE_COUNTING: "japaneseCounting";
+  readonly AIUEO: "aiueo";
+  readonly IROHA: "iroha";
+  readonly DECIMAL_FULL_WIDTH: "decimalFullWidth";
+  readonly DECIMAL_HALF_WIDTH: "decimalHalfWidth";
+  readonly JAPANESE_LEGAL: "japaneseLegal";
+  readonly JAPANESE_DIGITAL_TEN_THOUSAND: "japaneseDigitalTenThousand";
+  readonly DECIMAL_ENCLOSED_CIRCLE: "decimalEnclosedCircle";
+  readonly DECIMAL_FULL_WIDTH2: "decimalFullWidth2";
+  readonly AIUEO_FULL_WIDTH: "aiueoFullWidth";
+  readonly IROHA_FULL_WIDTH: "irohaFullWidth";
+  readonly DECIMAL_ZERO: "decimalZero";
+  readonly BULLET: "bullet";
+  readonly GANADA: "ganada";
+  readonly CHOSUNG: "chosung";
+  readonly DECIMAL_ENCLOSED_FULLSTOP: "decimalEnclosedFullstop";
+  readonly DECIMAL_ENCLOSED_PARENTHESES: "decimalEnclosedParen";
+  readonly DECIMAL_ENCLOSED_CIRCLE_CHINESE: "decimalEnclosedCircleChinese";
+  readonly IDEOGRAPH_ENCLOSED_CIRCLE: "ideographEnclosedCircle";
+  readonly IDEOGRAPH_TRADITIONAL: "ideographTraditional";
+  readonly IDEOGRAPH_ZODIAC: "ideographZodiac";
+  readonly IDEOGRAPH_ZODIAC_TRADITIONAL: "ideographZodiacTraditional";
+  readonly TAIWANESE_COUNTING: "taiwaneseCounting";
+  readonly IDEOGRAPH_LEGAL_TRADITIONAL: "ideographLegalTraditional";
+  readonly TAIWANESE_COUNTING_THOUSAND: "taiwaneseCountingThousand";
+  readonly TAIWANESE_DIGITAL: "taiwaneseDigital";
+  readonly CHINESE_COUNTING: "chineseCounting";
+  readonly CHINESE_LEGAL_SIMPLIFIED: "chineseLegalSimplified";
+  readonly CHINESE_COUNTING_THOUSAND: "chineseCountingThousand";
+  readonly KOREAN_DIGITAL: "koreanDigital";
+  readonly KOREAN_COUNTING: "koreanCounting";
+  readonly KOREAN_LEGAL: "koreanLegal";
+  readonly KOREAN_DIGITAL2: "koreanDigital2";
+  readonly VIETNAMESE_COUNTING: "vietnameseCounting";
+  readonly RUSSIAN_LOWER: "russianLower";
+  readonly RUSSIAN_UPPER: "russianUpper";
+  readonly NONE: "none";
+  readonly NUMBER_IN_DASH: "numberInDash";
+  readonly HEBREW1: "hebrew1";
+  readonly HEBREW2: "hebrew2";
+  readonly ARABIC_ALPHA: "arabicAlpha";
+  readonly ARABIC_ABJAD: "arabicAbjad";
+  readonly HINDI_VOWELS: "hindiVowels";
+  readonly HINDI_CONSONANTS: "hindiConsonants";
+  readonly HINDI_NUMBERS: "hindiNumbers";
+  readonly HINDI_COUNTING: "hindiCounting";
+  readonly THAI_LETTERS: "thaiLetters";
+  readonly THAI_NUMBERS: "thaiNumbers";
+  readonly THAI_COUNTING: "thaiCounting";
+  readonly BAHT_TEXT: "bahtText";
+  readonly DOLLAR_TEXT: "dollarText";
+  readonly CUSTOM: "custom";
+};
+declare const LevelSuffix: {
+  readonly NOTHING: "nothing";
+  readonly SPACE: "space";
+  readonly TAB: "tab";
+};
+interface ILevelsOptions {
+  readonly level: number;
+  readonly format?: (typeof LevelFormat)[keyof typeof LevelFormat];
+  readonly text?: string;
+  readonly alignment?: (typeof AlignmentType)[keyof typeof AlignmentType];
+  readonly start?: number;
+  readonly suffix?: (typeof LevelSuffix)[keyof typeof LevelSuffix];
+  readonly isLegalNumberingStyle?: boolean;
+  readonly style?: {
+    readonly run?: IRunStylePropertiesOptions;
+    readonly paragraph?: ILevelParagraphStylePropertiesOptions;
+  };
+}
+declare class LevelBase extends XmlComponent {
+  private readonly paragraphProperties;
+  private readonly runProperties;
+  constructor({
+    level,
+    format,
+    text,
+    alignment,
+    start,
+    style,
+    suffix,
+    isLegalNumberingStyle
+  }: ILevelsOptions);
+}
+declare class Level extends LevelBase {}
+declare class LevelForOverride extends LevelBase {}
+//#endregion
+//#region src/file/numbering/num.d.ts
+interface IOverrideLevel {
+  readonly num: number;
+  readonly start?: number;
+}
+interface IConcreteNumberingOptions {
+  readonly numId: number;
+  readonly abstractNumId: number;
+  readonly reference: string;
+  readonly instance: number;
+  readonly overrideLevels?: readonly IOverrideLevel[];
+}
+declare class ConcreteNumbering extends XmlComponent {
+  readonly numId: number;
+  readonly reference: string;
+  readonly instance: number;
+  constructor(options: IConcreteNumberingOptions);
+}
+declare class LevelOverride extends XmlComponent {
+  constructor(levelNum: number, start?: number);
+}
+//#endregion
+//#region src/file/numbering/numbering.d.ts
+interface INumberingOptions {
+  readonly config: readonly {
+    readonly levels: readonly ILevelsOptions[];
+    readonly reference: string;
+  }[];
+}
+declare class Numbering extends XmlComponent {
+  private readonly abstractNumberingMap;
+  private readonly concreteNumberingMap;
+  private readonly referenceConfigMap;
+  private readonly abstractNumUniqueNumericId;
+  private readonly concreteNumUniqueNumericId;
+  constructor(options: INumberingOptions);
+  prepForXml(context: IContext): IXmlableObject | undefined;
+  createConcreteNumberingInstance(reference: string, instance: number): void;
+  get ConcreteNumbering(): readonly ConcreteNumbering[];
+  get ReferenceConfig(): readonly Record<string, any>[];
+}
+//#endregion
+//#region src/file/numbering/abstract-numbering.d.ts
+declare class AbstractNumbering extends XmlComponent {
+  readonly id: number;
+  constructor(id: number, levelOptions: readonly ILevelsOptions[]);
+}
+//#endregion
+//#region src/file/styles/defaults/paragraph-properties.d.ts
+declare class ParagraphPropertiesDefaults extends XmlComponent {
+  constructor(options?: IParagraphStylePropertiesOptions);
+}
+//#endregion
+//#region src/file/styles/defaults/run-properties.d.ts
+declare class RunPropertiesDefaults extends XmlComponent {
+  constructor(options?: IRunStylePropertiesOptions);
+}
+//#endregion
+//#region src/file/styles/defaults/document-defaults.d.ts
+interface IDocumentDefaultsOptions {
+  readonly paragraph?: IParagraphStylePropertiesOptions;
+  readonly run?: IRunStylePropertiesOptions;
+}
+declare class DocumentDefaults extends XmlComponent {
+  private readonly runPropertiesDefaults;
+  private readonly paragraphPropertiesDefaults;
+  constructor(options: IDocumentDefaultsOptions);
+}
+//#endregion
+//#region src/file/styles/style/style.d.ts
+interface IStyleAttributes {
+  readonly type?: string;
+  readonly styleId?: string;
+  readonly default?: boolean;
+  readonly customStyle?: string;
+}
+interface IStyleOptions {
+  readonly name?: string;
+  readonly basedOn?: string;
+  readonly next?: string;
+  readonly link?: string;
+  readonly uiPriority?: number;
+  readonly semiHidden?: boolean;
+  readonly unhideWhenUsed?: boolean;
+  readonly quickFormat?: boolean;
+}
+declare class Style extends XmlComponent {
+  constructor(attributes: IStyleAttributes, options: IStyleOptions);
+}
+//#endregion
+//#region src/file/styles/style/paragraph-style.d.ts
+type IBaseParagraphStyleOptions = {
+  readonly paragraph?: IParagraphStylePropertiesOptions;
+  readonly run?: IRunStylePropertiesOptions;
+} & IStyleOptions;
+type IParagraphStyleOptions = {
+  readonly id: string;
+} & IBaseParagraphStyleOptions;
+declare class StyleForParagraph extends Style {
+  private readonly paragraphProperties;
+  private readonly runProperties;
+  constructor(options: IParagraphStyleOptions);
+}
+//#endregion
+//#region src/file/styles/style/character-style.d.ts
+type IBaseCharacterStyleOptions = {
+  readonly run?: IRunStylePropertiesOptions;
+} & IStyleOptions;
+type ICharacterStyleOptions = {
+  readonly id: string;
+} & IBaseCharacterStyleOptions;
+declare class StyleForCharacter extends Style {
+  private readonly runProperties;
+  constructor(options: ICharacterStyleOptions);
+}
+//#endregion
+//#region src/file/styles/factory.d.ts
+interface IDefaultStylesOptions {
+  readonly document?: IDocumentDefaultsOptions;
+  readonly title?: IBaseParagraphStyleOptions;
+  readonly heading1?: IBaseParagraphStyleOptions;
+  readonly heading2?: IBaseParagraphStyleOptions;
+  readonly heading3?: IBaseParagraphStyleOptions;
+  readonly heading4?: IBaseParagraphStyleOptions;
+  readonly heading5?: IBaseParagraphStyleOptions;
+  readonly heading6?: IBaseParagraphStyleOptions;
+  readonly strong?: IBaseParagraphStyleOptions;
+  readonly listParagraph?: IBaseParagraphStyleOptions;
+  readonly hyperlink?: IBaseCharacterStyleOptions;
+  readonly footnoteReference?: IBaseCharacterStyleOptions;
+  readonly footnoteText?: IBaseParagraphStyleOptions;
+  readonly footnoteTextChar?: IBaseCharacterStyleOptions;
+  readonly endnoteReference?: IBaseCharacterStyleOptions;
+  readonly endnoteText?: IBaseParagraphStyleOptions;
+  readonly endnoteTextChar?: IBaseCharacterStyleOptions;
+}
+//#endregion
+//#region src/file/styles/styles.d.ts
+interface IStylesOptions {
+  readonly default?: IDefaultStylesOptions;
+  readonly initialStyles?: BaseXmlComponent;
+  readonly paragraphStyles?: readonly IParagraphStyleOptions[];
+  readonly characterStyles?: readonly ICharacterStyleOptions[];
+  readonly importedStyles?: readonly (XmlComponent | StyleForParagraph | StyleForCharacter | ImportedXmlComponent)[];
+}
+declare class Styles extends XmlComponent {
+  constructor(options: IStylesOptions);
+}
+//#endregion
+//#region src/file/core-properties/properties.d.ts
+interface IPropertiesOptions {
+  readonly sections: readonly ISectionOptions[];
+  readonly title?: string;
+  readonly subject?: string;
+  readonly creator?: string;
+  readonly keywords?: string;
+  readonly description?: string;
+  readonly lastModifiedBy?: string;
+  readonly revision?: number;
+  readonly externalStyles?: string;
+  readonly styles?: IStylesOptions;
+  readonly numbering?: INumberingOptions;
+  readonly comments?: ICommentsOptions;
+  readonly footnotes?: Readonly<Record<string, {
+    readonly children: readonly Paragraph[];
+  }>>;
+  readonly endnotes?: Readonly<Record<string, {
+    readonly children: readonly Paragraph[];
+  }>>;
+  readonly background?: IDocumentBackgroundOptions;
+  readonly features?: {
+    readonly trackRevisions?: boolean;
+    readonly updateFields?: boolean;
+  };
+  readonly compatabilityModeVersion?: number;
+  readonly compatibility?: ICompatibilityOptions;
+  readonly customProperties?: readonly ICustomPropertyOptions[];
+  readonly evenAndOddHeaderAndFooters?: boolean;
+  readonly defaultTabStop?: number;
+  readonly fonts?: readonly FontOptions[];
+  readonly hyphenation?: IHyphenationOptions;
+}
+declare class CoreProperties extends XmlComponent {
+  constructor(options: Omit<IPropertiesOptions, "sections">);
+}
+//#endregion
+//#region src/file/endnotes-wrapper.d.ts
+declare class EndnotesWrapper implements IViewWrapper {
+  private readonly endnotes;
+  private readonly relationships;
+  constructor();
+  get View(): Endnotes;
+  get Relationships(): Relationships;
+}
+//#endregion
+//#region src/file/footnotes-wrapper.d.ts
+declare class FootnotesWrapper implements IViewWrapper {
+  private readonly footnotess;
+  private readonly relationships;
+  constructor();
+  get View(): FootNotes;
+  get Relationships(): Relationships;
+}
+//#endregion
+//#region src/file/header.d.ts
+interface IHeaderOptions {
+  readonly children: readonly (Paragraph | Table)[];
+}
+declare class Header {
+  readonly options: IHeaderOptions;
+  constructor(options?: IHeaderOptions);
+}
+declare class Footer {
+  readonly options: IHeaderOptions;
+  constructor(options?: IHeaderOptions);
+}
+//#endregion
+//#region src/file/file.d.ts
+interface ISectionOptions {
+  readonly headers?: {
+    readonly default?: Header;
+    readonly first?: Header;
+    readonly even?: Header;
+  };
+  readonly footers?: {
+    readonly default?: Footer;
+    readonly first?: Footer;
+    readonly even?: Footer;
+  };
+  readonly properties?: ISectionPropertiesOptions;
+  readonly children: readonly FileChild[];
+}
+declare class File {
+  private currentRelationshipId;
+  private readonly documentWrapper;
+  private readonly headers;
+  private readonly footers;
+  private readonly coreProperties;
+  private readonly numbering;
+  private readonly media;
+  private readonly fileRelationships;
+  private readonly footnotesWrapper;
+  private readonly endnotesWrapper;
+  private readonly settings;
+  private readonly contentTypes;
+  private readonly customProperties;
+  private readonly appProperties;
+  private readonly styles;
+  private readonly comments;
+  private readonly fontWrapper;
+  constructor(options: IPropertiesOptions);
+  private addSection;
+  private createHeader;
+  private createFooter;
+  private addHeaderToDocument;
+  private addFooterToDocument;
+  private addDefaultRelationships;
+  get Document(): DocumentWrapper;
+  get Styles(): Styles;
+  get CoreProperties(): CoreProperties;
+  get Numbering(): Numbering;
+  get Media(): Media;
+  get FileRelationships(): Relationships;
+  get Headers(): readonly HeaderWrapper[];
+  get Footers(): readonly FooterWrapper[];
+  get ContentTypes(): ContentTypes;
+  get CustomProperties(): CustomProperties;
+  get AppProperties(): AppProperties;
+  get FootNotes(): FootnotesWrapper;
+  get Endnotes(): EndnotesWrapper;
+  get Settings(): Settings;
+  get Comments(): Comments;
+  get FontTable(): FontWrapper;
+}
+//#endregion
+//#region src/file/xml-components/xmlable-object.d.ts
+type IXmlAttribute = Readonly<Record<string, string | number | boolean>>;
+type IXmlableObject = Readonly<Record<string, any>>;
+declare const WORKAROUND3 = "";
+//#endregion
+//#region src/file/xml-components/base.d.ts
+interface IContext {
+  readonly file: File;
+  readonly viewWrapper: IViewWrapper;
+  readonly stack: IXmlableObject[];
+}
+declare abstract class BaseXmlComponent {
+  protected readonly rootKey: string;
+  constructor(rootKey: string);
+  abstract prepForXml(context: IContext): IXmlableObject | undefined;
+}
+//#endregion
+//#region src/file/xml-components/xml-component.d.ts
+declare const EMPTY_OBJECT: {};
+declare abstract class XmlComponent extends BaseXmlComponent {
+  protected root: (BaseXmlComponent | IXmlableObject | string)[];
+  constructor(rootKey: string);
+  prepForXml(context: IContext): IXmlableObject | undefined;
+  addChildElement(child: XmlComponent | string): XmlComponent;
+}
+declare abstract class IgnoreIfEmptyXmlComponent extends XmlComponent {
+  private readonly includeIfEmpty;
+  constructor(rootKey: string, includeIfEmpty?: boolean);
+  prepForXml(context: IContext): IXmlableObject | undefined;
+}
+//#endregion
+//#region src/file/xml-components/default-attributes.d.ts
+type AttributeMap<T> = Record<keyof T, string>;
+type AttributeData = Record<string, boolean | number | string>;
+type AttributePayload<T> = { readonly [P in keyof T]: {
+  readonly key: string;
+  readonly value: T[P];
+} };
+declare abstract class XmlAttributeComponent<T extends Record<string, any>> extends BaseXmlComponent {
+  private readonly root;
+  protected readonly xmlKeys?: AttributeMap<T>;
+  constructor(root: T);
+  prepForXml(_: IContext): IXmlableObject;
+}
+declare class NextAttributeComponent<T> extends BaseXmlComponent {
+  private readonly root;
+  constructor(root: AttributePayload<T>);
+  prepForXml(_: IContext): IXmlableObject;
+}
+//#endregion
+//#region src/file/xml-components/attributes.d.ts
+declare class Attributes extends XmlAttributeComponent<{
+  readonly val?: string | number | boolean;
+  readonly color?: string;
+  readonly fill?: string;
+  readonly space?: string;
+  readonly sz?: string;
+  readonly type?: string;
+  readonly rsidR?: string;
+  readonly rsidRPr?: string;
+  readonly rsidSect?: string;
+  readonly w?: string;
+  readonly h?: string;
+  readonly top?: string;
+  readonly right?: string;
+  readonly bottom?: string;
+  readonly left?: string;
+  readonly header?: string;
+  readonly footer?: string;
+  readonly gutter?: string;
+  readonly linePitch?: string;
+  readonly pos?: string | number;
+}> {
+  protected readonly xmlKeys: {
+    bottom: string;
+    color: string;
+    fill: string;
+    footer: string;
+    gutter: string;
+    h: string;
+    header: string;
+    left: string;
+    linePitch: string;
+    pos: string;
+    right: string;
+    rsidR: string;
+    rsidRPr: string;
+    rsidSect: string;
+    space: string;
+    sz: string;
+    top: string;
+    type: string;
+    val: string;
+    w: string;
+  };
+}
+//#endregion
+//#region src/file/xml-components/imported-xml-component.d.ts
+declare const convertToXmlComponent: (element: Element) => ImportedXmlComponent | string | undefined;
+declare class ImportedXmlComponent extends XmlComponent {
+  static fromXmlString(importedContent: string): ImportedXmlComponent;
+  constructor(rootKey: string, _attr?: any);
+  push(xmlComponent: XmlComponent | string): void;
+}
+declare class ImportedRootElementAttributes extends XmlComponent {
+  private readonly _attr;
+  constructor(_attr: any);
+  prepForXml(_: IContext): IXmlableObject;
+}
+//#endregion
+//#region src/file/xml-components/initializable-xml-component.d.ts
+declare abstract class InitializableXmlComponent extends XmlComponent {
+  constructor(rootKey: string, initComponent?: InitializableXmlComponent);
+}
+//#endregion
+//#region src/file/xml-components/simple-elements.d.ts
+declare class OnOffElement extends XmlComponent {
+  constructor(name: string, val?: boolean | undefined);
+}
+declare class HpsMeasureElement extends XmlComponent {
+  constructor(name: string, val: number | PositiveUniversalMeasure);
+}
+declare class EmptyElement extends XmlComponent {}
+declare class StringValueElement extends XmlComponent {
+  constructor(name: string, val: string);
+}
+declare const createStringElement: (name: string, value: string) => XmlComponent;
+declare class NumberValueElement extends XmlComponent {
+  constructor(name: string, val: number);
+}
+declare class StringEnumValueElement<T extends string> extends XmlComponent {
+  constructor(name: string, val: T);
+}
+declare class StringContainer extends XmlComponent {
+  constructor(name: string, val: string);
+}
+declare class BuilderElement<T = {}> extends XmlComponent {
+  constructor({
+    name,
+    attributes,
+    children
+  }: {
+    readonly name: string;
+    readonly attributes?: AttributePayload<T>;
+    readonly children?: readonly XmlComponent[];
+  });
+}
+//#endregion
+//#region src/file/paragraph/formatting/alignment.d.ts
+declare const AlignmentType: {
+  readonly START: "start";
+  readonly CENTER: "center";
+  readonly END: "end";
+  readonly BOTH: "both";
+  readonly MEDIUM_KASHIDA: "mediumKashida";
+  readonly DISTRIBUTE: "distribute";
+  readonly NUM_TAB: "numTab";
+  readonly HIGH_KASHIDA: "highKashida";
+  readonly LOW_KASHIDA: "lowKashida";
+  readonly THAI_DISTRIBUTE: "thaiDistribute";
+  readonly LEFT: "left";
+  readonly RIGHT: "right";
+  readonly JUSTIFIED: "both";
+};
+declare const createAlignment: (type: (typeof AlignmentType)[keyof typeof AlignmentType]) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/formatting/break.d.ts
+declare class PageBreak extends Run {
+  constructor();
+}
+declare class ColumnBreak extends Run {
+  constructor();
+}
+declare class PageBreakBefore extends XmlComponent {
+  constructor();
+}
+//#endregion
+//#region src/file/paragraph/formatting/unordered-list.d.ts
+declare class NumberProperties extends XmlComponent {
+  constructor(numberId: number | string, indentLevel: number);
+}
+//#endregion
+//#region src/file/checkbox/checkbox-util.d.ts
+interface ICheckboxSymbolProperties {
+  readonly value?: string;
+  readonly font?: string;
+}
+interface ICheckboxSymbolOptions {
+  readonly alias?: string;
+  readonly checked?: boolean;
+  readonly checkedState?: ICheckboxSymbolProperties;
+  readonly uncheckedState?: ICheckboxSymbolProperties;
+}
+declare class CheckBoxUtil extends XmlComponent {
+  private readonly DEFAULT_UNCHECKED_SYMBOL;
+  private readonly DEFAULT_CHECKED_SYMBOL;
+  private readonly DEFAULT_FONT;
+  constructor(options?: ICheckboxSymbolOptions);
+}
+//#endregion
+//#region src/file/checkbox/checkbox-symbol.d.ts
+declare class CheckBoxSymbolElement extends XmlComponent {
+  constructor(name: string, val: string, font?: string);
+}
+//#endregion
+//#region src/file/checkbox/checkbox.d.ts
+declare class CheckBox extends XmlComponent {
+  private readonly DEFAULT_UNCHECKED_SYMBOL;
+  private readonly DEFAULT_CHECKED_SYMBOL;
+  private readonly DEFAULT_FONT;
+  constructor(options?: ICheckboxSymbolOptions);
+}
+//#endregion
+//#region src/file/paragraph/links/hyperlink.d.ts
+declare const HyperlinkType: {
+  readonly INTERNAL: "INTERNAL";
+  readonly EXTERNAL: "EXTERNAL";
+};
+interface IInternalHyperlinkOptions {
+  readonly children: readonly ParagraphChild[];
+  readonly anchor: string;
+}
+interface IExternalHyperlinkOptions {
+  readonly children: readonly ParagraphChild[];
+  readonly link: string;
+}
+declare class ConcreteHyperlink extends XmlComponent {
+  readonly linkId: string;
+  constructor(children: readonly ParagraphChild[], relationshipId: string, anchor?: string);
+}
+declare class InternalHyperlink extends ConcreteHyperlink {
+  constructor(options: IInternalHyperlinkOptions);
+}
+declare class ExternalHyperlink extends XmlComponent {
+  readonly options: IExternalHyperlinkOptions;
+  constructor(options: IExternalHyperlinkOptions);
+}
+//#endregion
+//#region src/file/paragraph/links/bookmark.d.ts
+interface IBookmarkOptions {
+  readonly id: string;
+  readonly children: readonly ParagraphChild[];
+}
+declare class Bookmark {
+  private readonly bookmarkUniqueNumericId;
+  readonly start: BookmarkStart;
+  readonly children: readonly ParagraphChild[];
+  readonly end: BookmarkEnd;
+  constructor(options: IBookmarkOptions);
+}
+declare class BookmarkStart extends XmlComponent {
+  constructor(id: string, linkId: number);
+}
+declare class BookmarkEnd extends XmlComponent {
+  constructor(linkId: number);
+}
+//#endregion
+//#region src/file/paragraph/links/numbered-item-ref.d.ts
+declare enum NumberedItemReferenceFormat {
+  NONE = "none",
+  RELATIVE = "relative",
+  NO_CONTEXT = "no_context",
+  FULL_CONTEXT = "full_context"
+}
+interface INumberedItemReferenceOptions {
+  readonly hyperlink?: boolean;
+  readonly referenceFormat?: NumberedItemReferenceFormat;
+}
+declare class NumberedItemReference extends SimpleField {
+  constructor(bookmarkId: string, cachedValue?: string, options?: INumberedItemReferenceOptions);
+}
+//#endregion
+//#region src/file/paragraph/links/outline-level.d.ts
+declare const createOutlineLevel: (level: number) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/links/pageref.d.ts
+interface IPageReferenceOptions {
+  readonly hyperlink?: boolean;
+  readonly useRelativePosition?: boolean;
+}
+declare class PageReference extends Run {
+  constructor(bookmarkId: string, options?: IPageReferenceOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/brackets/math-round-brackets.d.ts
+declare class MathRoundBrackets extends XmlComponent {
+  constructor(options: {
+    readonly children: readonly MathComponent[];
+  });
+}
+//#endregion
+//#region src/file/paragraph/math/brackets/math-square-brackets.d.ts
+declare class MathSquareBrackets extends XmlComponent {
+  constructor(options: {
+    readonly children: readonly MathComponent[];
+  });
+}
+//#endregion
+//#region src/file/paragraph/math/brackets/math-curly-brackets.d.ts
+declare class MathCurlyBrackets extends XmlComponent {
+  constructor(options: {
+    readonly children: readonly MathComponent[];
+  });
+}
+//#endregion
+//#region src/file/paragraph/math/brackets/math-angled-brackets.d.ts
+interface MathAngledBracketsOptions {
+  readonly children: readonly MathComponent[];
+}
+declare class MathAngledBrackets extends XmlComponent {
+  constructor(options: MathAngledBracketsOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/fraction/math-fraction.d.ts
+interface IMathFractionOptions {
+  readonly numerator: readonly MathComponent[];
+  readonly denominator: readonly MathComponent[];
+}
+declare class MathFraction extends XmlComponent {
+  constructor(options: IMathFractionOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/fraction/math-denominator.d.ts
+declare class MathDenominator extends XmlComponent {
+  constructor(children: readonly MathComponent[]);
+}
+//#endregion
+//#region src/file/paragraph/math/fraction/math-numerator.d.ts
+declare class MathNumerator extends XmlComponent {
+  constructor(children: readonly MathComponent[]);
+}
+//#endregion
+//#region src/file/paragraph/math/function/math-function.d.ts
+interface IMathFunctionOptions {
+  readonly children: readonly MathComponent[];
+  readonly name: readonly MathComponent[];
+}
+declare class MathFunction extends XmlComponent {
+  constructor(options: IMathFunctionOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/function/math-function-name.d.ts
+declare class MathFunctionName extends XmlComponent {
+  constructor(children: readonly MathComponent[]);
+}
+//#endregion
+//#region src/file/paragraph/math/function/math-function-properties.d.ts
+declare class MathFunctionProperties extends XmlComponent {
+  constructor();
+}
+//#endregion
+//#region src/file/paragraph/math/math-run.d.ts
+declare class MathRun extends XmlComponent {
+  constructor(text: string);
+}
+//#endregion
+//#region src/file/paragraph/math/n-ary/math-accent-character.d.ts
+interface MathAccentCharacterOptions {
+  readonly accent: string;
+}
+declare const createMathAccentCharacter: ({
+  accent
+}: MathAccentCharacterOptions) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/math/n-ary/math-base.d.ts
+interface MathBaseOptions {
+  readonly children: readonly MathComponent[];
+}
+declare const createMathBase: ({
+  children
+}: MathBaseOptions) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/math/n-ary/math-limit-location.d.ts
+interface MathLimitLocationOptions {
+  readonly value?: string;
+}
+declare const createMathLimitLocation: ({
+  value
+}: MathLimitLocationOptions) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/math/n-ary/math-n-ary-properties.d.ts
+interface MathNAryPropertiesOptions {
+  readonly accent: string;
+  readonly hasSuperScript: boolean;
+  readonly hasSubScript: boolean;
+  readonly limitLocationVal?: string;
+}
+declare const createMathNAryProperties: ({
+  accent,
+  hasSuperScript,
+  hasSubScript,
+  limitLocationVal
+}: MathNAryPropertiesOptions) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/math/n-ary/math-sub-script.d.ts
+interface MathSubScriptElementOptions {
+  readonly children: readonly MathComponent[];
+}
+declare const createMathSubScriptElement: ({
+  children
+}: MathSubScriptElementOptions) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/math/n-ary/math-sum.d.ts
+interface IMathSumOptions {
+  readonly children: readonly MathComponent[];
+  readonly subScript?: readonly MathComponent[];
+  readonly superScript?: readonly MathComponent[];
+}
+declare class MathSum extends XmlComponent {
+  constructor(options: IMathSumOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/n-ary/math-integral.d.ts
+interface IMathIntegralOptions {
+  readonly children: readonly MathComponent[];
+  readonly subScript?: readonly MathComponent[];
+  readonly superScript?: readonly MathComponent[];
+}
+declare class MathIntegral extends XmlComponent {
+  constructor(options: IMathIntegralOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/n-ary/math-super-script.d.ts
+interface MathSuperScriptElementOptions {
+  readonly children: readonly MathComponent[];
+}
+declare const createMathSuperScriptElement: ({
+  children
+}: MathSuperScriptElementOptions) => XmlComponent;
+//#endregion
+//#region src/file/paragraph/math/n-ary/math-limit.d.ts
+declare class MathLimit extends XmlComponent {
+  constructor(children: readonly MathComponent[]);
+}
+//#endregion
+//#region src/file/paragraph/math/n-ary/math-limit-upper.d.ts
+interface IMathLimitUpperOptions {
+  readonly children: readonly MathComponent[];
+  readonly limit: readonly MathComponent[];
+}
+declare class MathLimitUpper extends XmlComponent {
+  constructor(options: IMathLimitUpperOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/n-ary/math-limit-lower.d.ts
+interface IMathLimitLowerOptions {
+  readonly children: readonly MathComponent[];
+  readonly limit: readonly MathComponent[];
+}
+declare class MathLimitLower extends XmlComponent {
+  constructor(options: IMathLimitLowerOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/radical/math-degree.d.ts
+declare class MathDegree extends XmlComponent {
+  constructor(children?: readonly MathComponent[]);
+}
+//#endregion
+//#region src/file/paragraph/math/radical/math-radical.d.ts
+interface IMathRadicalOptions {
+  readonly children: readonly MathComponent[];
+  readonly degree?: readonly MathComponent[];
+}
+declare class MathRadical extends XmlComponent {
+  constructor(options: IMathRadicalOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/radical/math-radical-properties.d.ts
+declare class MathRadicalProperties extends XmlComponent {
+  constructor(hasDegree: boolean);
+}
+//#endregion
+//#region src/file/paragraph/math/script/super-script/math-super-script-function.d.ts
+interface IMathSuperScriptOptions {
+  readonly children: readonly MathComponent[];
+  readonly superScript: readonly MathComponent[];
+}
+declare class MathSuperScript extends XmlComponent {
+  constructor(options: IMathSuperScriptOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/script/super-script/math-super-script-function-properties.d.ts
+declare const createMathSuperScriptProperties: () => XmlComponent;
+//#endregion
+//#region src/file/paragraph/math/script/sub-script/math-sub-script-function.d.ts
+interface IMathSubScriptOptions {
+  readonly children: readonly MathComponent[];
+  readonly subScript: readonly MathComponent[];
+}
+declare class MathSubScript extends XmlComponent {
+  constructor(options: IMathSubScriptOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/script/sub-script/math-sub-script-function-properties.d.ts
+declare const createMathSubScriptProperties: () => XmlComponent;
+//#endregion
+//#region src/file/paragraph/math/script/sub-super-script/math-sub-super-script-function.d.ts
+interface IMathSubSuperScriptOptions {
+  readonly children: readonly MathComponent[];
+  readonly subScript: readonly MathComponent[];
+  readonly superScript: readonly MathComponent[];
+}
+declare class MathSubSuperScript extends XmlComponent {
+  constructor(options: IMathSubSuperScriptOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/script/sub-super-script/math-sub-super-script-function-properties.d.ts
+declare const createMathSubSuperScriptProperties: () => XmlComponent;
+//#endregion
+//#region src/file/paragraph/math/script/pre-sub-super-script/math-pre-sub-super-script-function.d.ts
+interface IMathPreSubSuperScriptOptions {
+  readonly children: readonly MathComponent[];
+  readonly subScript: readonly MathComponent[];
+  readonly superScript: readonly MathComponent[];
+}
+declare class MathPreSubSuperScript extends BuilderElement {
+  constructor({
+    children,
+    subScript,
+    superScript
+  }: IMathPreSubSuperScriptOptions);
+}
+//#endregion
+//#region src/file/paragraph/math/script/pre-sub-super-script/math-pre-sub-super-script-function-properties.d.ts
+declare const createMathPreSubSuperScriptProperties: () => XmlComponent;
+//#endregion
+//#region src/file/paragraph/math/math-component.d.ts
+type MathComponent = MathRun | MathFraction | MathSum | MathIntegral | MathSuperScript | MathSubScript | MathSubSuperScript | MathRadical | MathFunction | MathRoundBrackets | MathCurlyBrackets | MathAngledBrackets | MathSquareBrackets;
+declare const WORKAROUND4 = "";
+//#endregion
+//#region src/file/paragraph/math/math.d.ts
+interface IMathOptions {
+  readonly children: readonly MathComponent[];
+}
+declare class Math extends XmlComponent {
+  constructor(options: IMathOptions);
+}
+//#endregion
+//#region src/file/paragraph/paragraph.d.ts
+type ParagraphChild = TextRun | ImageRun | SymbolRun | Bookmark | PageBreak | ColumnBreak | SequentialIdentifier | FootnoteReferenceRun | InternalHyperlink | ExternalHyperlink | InsertedTextRun | DeletedTextRun | Math | SimpleField | SimpleMailMergeField | Comments | Comment | CommentRangeStart | CommentRangeEnd | CommentReference | CheckBox;
+type IParagraphOptions = {
+  readonly text?: string;
+  readonly children?: readonly ParagraphChild[];
+} & IParagraphPropertiesOptions;
+declare class Paragraph extends FileChild {
+  private readonly properties;
+  constructor(options: string | IParagraphOptions);
+  prepForXml(context: IContext): IXmlableObject | undefined;
+  addRunToFront(run: Run): Paragraph;
+}
+//#endregion
+//#region src/file/shared/space-type.d.ts
+declare const SpaceType: {
+  readonly DEFAULT: "default";
+  readonly PRESERVE: "preserve";
+};
+//#endregion
+//#region src/file/textbox/types.d.ts
+type LengthUnit = "auto" | number | Percentage | UniversalMeasure | RelativeMeasure;
+//#endregion
+//#region src/file/textbox/shape/shape.d.ts
+interface VmlShapeStyle {
+  readonly flip?: "x" | "y" | "xy" | "yx";
+  readonly height?: LengthUnit;
+  readonly left?: LengthUnit;
+  readonly marginBottom?: LengthUnit;
+  readonly marginLeft?: LengthUnit;
+  readonly marginRight?: LengthUnit;
+  readonly marginTop?: LengthUnit;
+  readonly positionHorizontal?: "absolute" | "left" | "center" | "right" | "inside" | "outside";
+  readonly positionHorizontalRelative?: "margin" | "page" | "text" | "char";
+  readonly positionVertical?: "absolute" | "left" | "center" | "right" | "inside" | "outside";
+  readonly positionVerticalRelative?: "margin" | "page" | "text" | "char";
+  readonly wrapDistanceBottom?: number;
+  readonly wrapDistanceLeft?: number;
+  readonly wrapDistanceRight?: number;
+  readonly wrapDistanceTop?: number;
+  readonly wrapEdited?: boolean;
+  readonly wrapStyle?: "square" | "none";
+  readonly position?: "static" | "absolute" | "relative";
+  readonly rotation?: number;
+  readonly top?: LengthUnit;
+  readonly visibility?: "hidden" | "inherit";
+  readonly width: LengthUnit;
+  readonly zIndex?: "auto" | number;
+}
+//#endregion
+//#region src/file/textbox/textbox.d.ts
+type ITextboxOptions = Omit<IParagraphOptions, "style"> & {
+  readonly style?: VmlShapeStyle;
+};
+declare class Textbox extends FileChild {
+  constructor({
+    style,
+    children,
+    ...rest
+  }: ITextboxOptions);
+}
+//#endregion
+//#region src/util/output-type.d.ts
+interface OutputByType {
+  readonly base64: string;
+  readonly string: string;
+  readonly text: string;
+  readonly binarystring: string;
+  readonly array: readonly number[];
+  readonly uint8array: Uint8Array;
+  readonly arraybuffer: ArrayBuffer;
+  readonly blob: Blob;
+  readonly nodebuffer: Buffer;
+}
+type OutputType = keyof OutputByType;
+declare const convertOutput: <T extends OutputType>(data: Uint8Array, type: T) => OutputByType[T];
+//#endregion
+//#region src/export/packer/next-compiler.d.ts
+interface IXmlifyedFile {
+  readonly data: string;
+  readonly path: string;
+}
+//#endregion
+//#region src/export/packer/packer.d.ts
+declare const PrettifyType: {
+  readonly NONE: "";
+  readonly WITH_2_BLANKS: "  ";
+  readonly WITH_4_BLANKS: "    ";
+  readonly WITH_TAB: "\t";
+};
+declare class Packer {
+  static pack<T extends OutputType>(file: File, type: T, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType], overrides?: readonly IXmlifyedFile[]): Promise<OutputByType[T]>;
+  static toString(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType], overrides?: readonly IXmlifyedFile[]): Promise<string>;
+  static toBuffer(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType], overrides?: readonly IXmlifyedFile[]): Promise<Buffer>;
+  static toBase64String(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType], overrides?: readonly IXmlifyedFile[]): Promise<string>;
+  static toBlob(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType], overrides?: readonly IXmlifyedFile[]): Promise<Blob>;
+  static toArrayBuffer(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType], overrides?: readonly IXmlifyedFile[]): Promise<ArrayBuffer>;
+  private static readonly compiler;
+}
+//#endregion
+//#region src/util/convenience-functions.d.ts
+declare const convertMillimetersToTwip: (millimeters: number) => number;
+declare const convertInchesToTwip: (inches: number) => number;
+type UniqueNumericIdCreator = () => number;
+declare const uniqueNumericIdCreator: (initial?: number) => UniqueNumericIdCreator;
+declare const abstractNumUniqueNumericIdGen: () => UniqueNumericIdCreator;
+declare const concreteNumUniqueNumericIdGen: () => UniqueNumericIdCreator;
+declare const docPropertiesUniqueNumericIdGen: () => UniqueNumericIdCreator;
+declare const bookmarkUniqueNumericIdGen: () => UniqueNumericIdCreator;
+declare const uniqueId: () => string;
+declare const hashedId: (data: Buffer | string | Uint8Array | ArrayBuffer) => string;
+declare const uniqueUuid: () => string;
+declare const encodeUtf8: (str: string) => Uint8Array;
+//#endregion
+//#region src/patcher/from-docx.d.ts
+type InputDataType = Buffer | string | number[] | Uint8Array | ArrayBuffer | Blob;
+declare const PatchType: {
+  readonly DOCUMENT: "file";
+  readonly PARAGRAPH: "paragraph";
+};
+interface ParagraphPatch {
+  readonly type: typeof PatchType.PARAGRAPH;
+  readonly children: readonly ParagraphChild[];
+}
+interface FilePatch {
+  readonly type: typeof PatchType.DOCUMENT;
+  readonly children: readonly FileChild[];
+}
+type IPatch = ParagraphPatch | FilePatch;
+type PatchDocumentOutputType = OutputType;
+interface PatchDocumentOptions<T extends PatchDocumentOutputType = PatchDocumentOutputType> {
+  readonly outputType: T;
+  readonly data: InputDataType;
+  readonly patches: Readonly<Record<string, IPatch>>;
+  readonly keepOriginalStyles?: boolean;
+  readonly placeholderDelimiters?: Readonly<{
+    readonly start: string;
+    readonly end: string;
+  }>;
+  readonly recursive?: boolean;
+}
+declare const patchDocument: <T extends PatchDocumentOutputType = PatchDocumentOutputType>({
+  outputType,
+  data,
+  patches,
+  keepOriginalStyles,
+  placeholderDelimiters,
+  recursive
+}: PatchDocumentOptions<T>) => Promise<OutputByType[T]>;
+//#endregion
+//#region src/patcher/patch-detector.d.ts
+interface PatchDetectorOptions {
+  readonly data: InputDataType;
+}
+declare const patchDetector: ({
+  data
+}: PatchDetectorOptions) => Promise<readonly string[]>;
+//#endregion
+export { AbstractNumbering, AlignmentType, AnnotationReference, AttributeData, AttributeMap, AttributePayload, Attributes, BaseXmlComponent, Body, Bookmark, BookmarkEnd, BookmarkStart, Border, BorderStyle, BuilderElement, CarriageReturn, CellMerge, CellMergeAttributes, CharacterSet, CheckBox, CheckBoxSymbolElement, CheckBoxUtil, Column, ColumnBreak, Comment, CommentRangeEnd, CommentRangeStart, CommentReference, Comments, ConcreteHyperlink, ConcreteNumbering, ContinuationSeparator, DayLong, DayShort, DeletedTableCell, DeletedTableRow, DeletedTextRun, File as Document, File, DocumentAttributeNamespace, DocumentAttributeNamespaces, DocumentAttributes, DocumentBackground, DocumentBackgroundAttributes, DocumentDefaults, DocumentGridType, Drawing, DropCapType, EMPTY_OBJECT, EmphasisMarkType, EmptyElement, EndnoteIdReference, EndnoteReference, EndnoteReferenceRun, EndnoteReferenceRunAttributes, Endnotes, ExternalHyperlink, FileChild, FootNoteReferenceRunAttributes, FootNotes, Footer, FooterWrapper, FootnoteReference, FootnoteReferenceElement, FootnoteReferenceRun, FrameAnchorType, FrameWrap, GridSpan, Header, HeaderFooterReferenceType, HeaderFooterType, HeaderWrapper, HeadingLevel, HeightRule, HighlightColor, HorizontalPositionAlign, HorizontalPositionRelativeFrom, HpsMeasureElement, HyperlinkType, IAlignmentFrameOptions, IBaseCharacterStyleOptions, IBaseParagraphStyleOptions, IBodyPropertiesOptions, IBookmarkOptions, IBorderOptions, IBordersOptions, ICellMergeAttributes, ICharacterStyleOptions, ICheckboxSymbolOptions, ICheckboxSymbolProperties, IColumnAttributes, IColumnsAttributes, ICommentOptions, ICommentsOptions, IConcreteNumberingOptions, IContext, IDistance, IDocGridAttributesProperties, IDocumentAttributesProperties, IDocumentBackgroundOptions, IDocumentDefaultsOptions, IDocumentFooter, IDocumentHeader, IDocumentOptions, IDrawingOptions, IExtendedMediaData, IExternalHyperlinkOptions, IFloating, IFontAttributesProperties, IFrameOptions, IGroupChildMediaData, IHeaderFooterGroup, IHeaderFooterOptions, IHeaderOptions, IHorizontalPositionOptions, IImageOptions, IIndentAttributesProperties, IInternalHyperlinkOptions, ILevelParagraphStylePropertiesOptions, ILevelsOptions, ILineNumberAttributes, IMargins, IMathFractionOptions, IMathFunctionOptions, IMathIntegralOptions, IMathLimitLowerOptions, IMathLimitUpperOptions, IMathOptions, IMathPreSubSuperScriptOptions, IMathRadicalOptions, IMathSubScriptOptions, IMathSubSuperScriptOptions, IMathSumOptions, IMathSuperScriptOptions, IMediaData, IMediaDataTransformation, IMediaTransformation, INumberedItemReferenceOptions, INumberingOptions, IPageBorderAttributes, IPageBordersOptions, IPageMarginAttributes, IPageNumberTypeAttributes, IPageReferenceOptions, IPageSizeAttributes, IParagraphOptions, IParagraphPropertiesChangeOptions, IParagraphPropertiesOptions, IParagraphPropertiesOptionsBase, IParagraphRunOptions, IParagraphRunPropertiesOptions, IParagraphStyleOptions, IParagraphStylePropertiesOptions, IPatch, type IPropertiesOptions, IRunOptions, IRunPropertiesChangeOptions, IRunPropertiesOptions, IRunStylePropertiesOptions, ISectionOptions, ISectionPropertiesChangeOptions, ISectionPropertiesOptions, ISectionPropertiesOptionsBase, IShadingAttributesProperties, ISpacingProperties, IStylesOptions, ISymbolRunOptions, ITableBordersOptions, ITableCellBorders, ITableCellOptions, ITableFloatOptions, ITableLookOptions, ITableOfContentsOptions, ITableOptions, ITablePropertiesChangeOptions, ITablePropertiesOptions, ITablePropertiesOptionsBase, ITableRowOptions, ITableRowPropertiesChangeOptions, ITableRowPropertiesOptions, ITableRowPropertiesOptionsBase, ITableWidthProperties, ITextWrapping, IVerticalPositionOptions, IWpgGroupOptions, IWpsShapeOptions, IXYFrameOptions, IXmlAttribute, IXmlableObject, IgnoreIfEmptyXmlComponent, ImageRun, ImportedRootElementAttributes, ImportedXmlComponent, InitializableXmlComponent, InputDataType, InsertedTableCell, InsertedTableRow, InsertedTextRun, InternalHyperlink, LastRenderedPageBreak, LeaderType, Level, LevelBase, LevelForOverride, LevelFormat, LevelOverride, LevelSuffix, LineNumberRestartFormat, LineRuleType, Math, MathAngledBrackets, MathComponent, MathCurlyBrackets, MathDegree, MathDenominator, MathFraction, MathFunction, MathFunctionName, MathFunctionProperties, MathIntegral, MathLimit, MathLimitLower, MathLimitUpper, MathNumerator, MathPreSubSuperScript, MathRadical, MathRadicalProperties, MathRoundBrackets, MathRun, MathSquareBrackets, MathSubScript, MathSubSuperScript, MathSum, MathSuperScript, Media, MonthLong, MonthShort, NextAttributeComponent, NoBreakHyphen, NumberFormat, NumberProperties, NumberValueElement, NumberedItemReference, NumberedItemReferenceFormat, Numbering, OnOffElement, OutputByType, OutputType, OverlapType, Packer, PageBorderDisplay, PageBorderOffsetFrom, PageBorderZOrder, PageBorders, PageBreak, PageBreakBefore, PageNumber, PageNumberElement, PageNumberSeparator, PageOrientation, PageReference, PageTextDirection, PageTextDirectionType, Paragraph, ParagraphChild, ParagraphProperties, ParagraphPropertiesChange, ParagraphPropertiesDefaults, ParagraphRunProperties, PatchDocumentOptions, PatchDocumentOutputType, PatchType, Percentage, PositionalTab, PositionalTabAlignment, PositionalTabLeader, PositionalTabOptions, PositionalTabRelativeTo, PositivePercentage, PositiveUniversalMeasure, PrettifyType, RelativeHorizontalPosition, RelativeMeasure, RelativeVerticalPosition, Run, RunProperties, RunPropertiesChange, RunPropertiesDefaults, SectionProperties, SectionPropertiesChange, SectionType, SectionVerticalAlign, Separator, SequentialIdentifier, ShadingType, SimpleField, SimpleMailMergeField, SoftHyphen, SpaceType, StringContainer, StringEnumValueElement, StringValueElement, StyleForCharacter, StyleForParagraph, StyleLevel, Styles, SymbolRun, TDirection, Tab, TabStopDefinition, TabStopPosition, TabStopType, Table, TableAnchorType, TableBorders, TableCell, TableCellBorders, TableLayoutType, TableOfContents, TableProperties, TableRow, TableRowProperties, TableRowPropertiesChange, TableVerticalAlign, TextDirection, TextEffect, TextRun, TextWrappingSide, TextWrappingType, Textbox, ThematicBreak, UnderlineType, UniqueNumericIdCreator, UniversalMeasure, VerticalAlign, VerticalAlignSection, VerticalAlignTable, VerticalAnchor, VerticalMerge, VerticalMergeRevisionType, VerticalMergeType, VerticalPositionAlign, VerticalPositionRelativeFrom, WORKAROUND2, WORKAROUND3, WORKAROUND4, WidthType, WpgCommonMediaData, WpgGroupRun, WpgMediaData, WpsMediaData, WpsShapeRun, XmlAttributeComponent, XmlComponent, YearLong, YearShort, abstractNumUniqueNumericIdGen, bookmarkUniqueNumericIdGen, concreteNumUniqueNumericIdGen, convertInchesToTwip, convertMillimetersToTwip, convertOutput, convertToXmlComponent, createAlignment, createBodyProperties, createBorderElement, createColumns, createDocumentGrid, createDotEmphasisMark, createEmphasisMark, createFrameProperties, createHeaderFooterReference, createHorizontalPosition, createIndent, createLineNumberType, createMathAccentCharacter, createMathBase, createMathLimitLocation, createMathNAryProperties, createMathPreSubSuperScriptProperties, createMathSubScriptElement, createMathSubScriptProperties, createMathSubSuperScriptProperties, createMathSuperScriptElement, createMathSuperScriptProperties, createOutlineLevel, createPageMargin, createPageNumberType, createPageSize, createParagraphStyle, createRunFonts, createSectionType, createShading, createSimplePos, createSpacing, createStringElement, createTabStop, createTabStopItem, createTableFloatProperties, createTableLayout, createTableLook, createTableRowHeight, createTableWidthElement, createTransformation, createUnderline, createVerticalAlign, createVerticalPosition, createWrapNone, createWrapSquare, createWrapTight, createWrapTopAndBottom, dateTimeValue, decimalNumber, docPropertiesUniqueNumericIdGen, eighthPointMeasureValue, encodeUtf8, hashedId, hexColorValue, hpsMeasureValue, longHexNumber, measurementOrPercentValue, patchDetector, patchDocument, percentageValue, pointMeasureValue, positiveUniversalMeasureValue, sectionMarginDefaults, sectionPageSizeDefaults, shortHexNumber, signedHpsMeasureValue, signedTwipsMeasureValue, standardizeData, twipsMeasureValue, uCharHexNumber, uniqueId, uniqueNumericIdCreator, uniqueUuid, universalMeasureValue, unsignedDecimalNumber };