docx 8.2.4 → 8.3.0

package/build/export/packer/next-compiler.d.ts

@@ -6,6 +6,6 @@ export declare class Compiler {
     private readonly imageReplacer;
     private readonly numberingReplacer;
     constructor();
-    compile(file: File, prettifyXml?: PrettifyType): JSZip;
+    compile(file: File, prettifyXml?: (typeof PrettifyType)[keyof typeof PrettifyType]): JSZip;
     private xmlifyFile;
 }

package/build/export/packer/packer.d.ts

@@ -2,17 +2,17 @@
 /// <reference types="node" />
 import { Stream } from "stream";
 import { File } from '../../file/file';
-export declare enum PrettifyType {
-    NONE = "",
-    WITH_2_BLANKS = "  ",
-    WITH_4_BLANKS = "    ",
-    WITH_TAB = "\t"
-}
+export declare const PrettifyType: {
+    readonly NONE: "";
+    readonly WITH_2_BLANKS: "  ";
+    readonly WITH_4_BLANKS: "    ";
+    readonly WITH_TAB: "\t";
+};
 export declare class Packer {
-    static toString(file: File, prettify?: boolean | PrettifyType): Promise<string>;
-    static toBuffer(file: File, prettify?: boolean | PrettifyType): Promise<Buffer>;
-    static toBase64String(file: File, prettify?: boolean | PrettifyType): Promise<string>;
-    static toBlob(file: File, prettify?: boolean | PrettifyType): Promise<Blob>;
-    static toStream(file: File, prettify?: boolean | PrettifyType): Stream;
+    static toString(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType]): Promise<string>;
+    static toBuffer(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType]): Promise<Buffer>;
+    static toBase64String(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType]): Promise<string>;
+    static toBlob(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType]): Promise<Blob>;
+    static toStream(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType]): Stream;
     private static readonly compiler;
 }

package/build/file/border/border.d.ts

@@ -1,6 +1,6 @@
 import { XmlComponent } from '../xml-components';
 export interface IBorderOptions {
-    readonly style: BorderStyle;
+    readonly style: (typeof BorderStyle)[keyof typeof BorderStyle];
     readonly color?: string;
     readonly size?: number;
     readonly space?: number;
@@ -8,32 +8,32 @@ export interface IBorderOptions {
 export declare class BorderElement extends XmlComponent {
     constructor(elementName: string, { color, size, space, style }: IBorderOptions);
 }
-export declare enum BorderStyle {
-    SINGLE = "single",
-    DASH_DOT_STROKED = "dashDotStroked",
-    DASHED = "dashed",
-    DASH_SMALL_GAP = "dashSmallGap",
-    DOT_DASH = "dotDash",
-    DOT_DOT_DASH = "dotDotDash",
-    DOTTED = "dotted",
-    DOUBLE = "double",
-    DOUBLE_WAVE = "doubleWave",
-    INSET = "inset",
-    NIL = "nil",
-    NONE = "none",
-    OUTSET = "outset",
-    THICK = "thick",
-    THICK_THIN_LARGE_GAP = "thickThinLargeGap",
-    THICK_THIN_MEDIUM_GAP = "thickThinMediumGap",
-    THICK_THIN_SMALL_GAP = "thickThinSmallGap",
-    THIN_THICK_LARGE_GAP = "thinThickLargeGap",
-    THIN_THICK_MEDIUM_GAP = "thinThickMediumGap",
-    THIN_THICK_SMALL_GAP = "thinThickSmallGap",
-    THIN_THICK_THIN_LARGE_GAP = "thinThickThinLargeGap",
-    THIN_THICK_THIN_MEDIUM_GAP = "thinThickThinMediumGap",
-    THIN_THICK_THIN_SMALL_GAP = "thinThickThinSmallGap",
-    THREE_D_EMBOSS = "threeDEmboss",
-    THREE_D_ENGRAVE = "threeDEngrave",
-    TRIPLE = "triple",
-    WAVE = "wave"
-}
+export 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";
+};

package/build/file/document/body/section-properties/properties/doc-grid.d.ts

@@ -1,12 +1,12 @@
 import { XmlAttributeComponent, XmlComponent } from '../../../../xml-components';
-export declare enum DocumentGridType {
-    DEFAULT = "default",
-    LINES = "lines",
-    LINES_AND_CHARS = "linesAndChars",
-    SNAP_TO_CHARS = "snapToChars"
-}
+export declare const DocumentGridType: {
+    readonly DEFAULT: "default";
+    readonly LINES: "lines";
+    readonly LINES_AND_CHARS: "linesAndChars";
+    readonly SNAP_TO_CHARS: "snapToChars";
+};
 export interface IDocGridAttributesProperties {
-    readonly type?: DocumentGridType;
+    readonly type?: (typeof DocumentGridType)[keyof typeof DocumentGridType];
     readonly linePitch?: number;
     readonly charSpace?: number;
 }
@@ -18,5 +18,5 @@ export declare class DocGridAttributes extends XmlAttributeComponent<IDocGridAtt
     };
 }
 export declare class DocumentGrid extends XmlComponent {
-    constructor(linePitch: number, charSpace?: number, type?: DocumentGridType);
+    constructor(linePitch: number, charSpace?: number, type?: (typeof DocumentGridType)[keyof typeof DocumentGridType]);
 }

package/build/file/document/body/section-properties/properties/header-footer-reference.d.ts

@@ -1,17 +1,17 @@
 import { XmlComponent } from '../../../../xml-components';
-export declare enum HeaderFooterReferenceType {
-    DEFAULT = "default",
-    FIRST = "first",
-    EVEN = "even"
-}
+export declare const HeaderFooterReferenceType: {
+    readonly DEFAULT: "default";
+    readonly FIRST: "first";
+    readonly EVEN: "even";
+};
 export interface IHeaderFooterOptions {
-    readonly type?: HeaderFooterReferenceType;
+    readonly type?: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType];
     readonly id?: number;
 }
-export declare enum HeaderFooterType {
-    HEADER = "w:headerReference",
-    FOOTER = "w:footerReference"
-}
+export declare const HeaderFooterType: {
+    readonly HEADER: "w:headerReference";
+    readonly FOOTER: "w:footerReference";
+};
 export declare class HeaderFooterReference extends XmlComponent {
-    constructor(type: HeaderFooterType, options: IHeaderFooterOptions);
+    constructor(type: (typeof HeaderFooterType)[keyof typeof HeaderFooterType], options: IHeaderFooterOptions);
 }

package/build/file/document/body/section-properties/properties/line-number.d.ts

@@ -1,14 +1,14 @@
 import { XmlComponent } from '../../../../xml-components';
 import { PositiveUniversalMeasure } from '../../../../../util/values';
-export declare enum LineNumberRestartFormat {
-    NEW_PAGE = "newPage",
-    NEW_SECTION = "newSection",
-    CONTINUOUS = "continuous"
-}
+export declare const LineNumberRestartFormat: {
+    readonly NEW_PAGE: "newPage";
+    readonly NEW_SECTION: "newSection";
+    readonly CONTINUOUS: "continuous";
+};
 export interface ILineNumberAttributes {
     readonly countBy?: number;
     readonly start?: number;
-    readonly restart?: LineNumberRestartFormat;
+    readonly restart?: (typeof LineNumberRestartFormat)[keyof typeof LineNumberRestartFormat];
     readonly distance?: number | PositiveUniversalMeasure;
 }
 export declare class LineNumberType extends XmlComponent {

package/build/file/document/body/section-properties/properties/page-borders.d.ts

@@ -1,22 +1,22 @@
 import { IBorderOptions } from '../../../../border';
 import { IgnoreIfEmptyXmlComponent } from '../../../../xml-components';
-export declare enum PageBorderDisplay {
-    ALL_PAGES = "allPages",
-    FIRST_PAGE = "firstPage",
-    NOT_FIRST_PAGE = "notFirstPage"
-}
-export declare enum PageBorderOffsetFrom {
-    PAGE = "page",
-    TEXT = "text"
-}
-export declare enum PageBorderZOrder {
-    BACK = "back",
-    FRONT = "front"
-}
+export declare const PageBorderDisplay: {
+    readonly ALL_PAGES: "allPages";
+    readonly FIRST_PAGE: "firstPage";
+    readonly NOT_FIRST_PAGE: "notFirstPage";
+};
+export declare const PageBorderOffsetFrom: {
+    readonly PAGE: "page";
+    readonly TEXT: "text";
+};
+export declare const PageBorderZOrder: {
+    readonly BACK: "back";
+    readonly FRONT: "front";
+};
 export interface IPageBorderAttributes {
-    readonly display?: PageBorderDisplay;
-    readonly offsetFrom?: PageBorderOffsetFrom;
-    readonly zOrder?: PageBorderZOrder;
+    readonly display?: (typeof PageBorderDisplay)[keyof typeof PageBorderDisplay];
+    readonly offsetFrom?: (typeof PageBorderOffsetFrom)[keyof typeof PageBorderOffsetFrom];
+    readonly zOrder?: (typeof PageBorderZOrder)[keyof typeof PageBorderZOrder];
 }
 export interface IPageBordersOptions {
     readonly pageBorders?: IPageBorderAttributes;

package/build/file/document/body/section-properties/properties/page-number.d.ts

@@ -1,16 +1,16 @@
 import { NumberFormat } from '../../../../shared/number-format';
 import { XmlAttributeComponent, XmlComponent } from '../../../../xml-components';
-export declare enum PageNumberSeparator {
-    HYPHEN = "hyphen",
-    PERIOD = "period",
-    COLON = "colon",
-    EM_DASH = "emDash",
-    EN_DASH = "endash"
-}
+export declare const PageNumberSeparator: {
+    readonly HYPHEN: "hyphen";
+    readonly PERIOD: "period";
+    readonly COLON: "colon";
+    readonly EM_DASH: "emDash";
+    readonly EN_DASH: "endash";
+};
 export interface IPageNumberTypeAttributes {
     readonly start?: number;
-    readonly formatType?: NumberFormat;
-    readonly separator?: PageNumberSeparator;
+    readonly formatType?: (typeof NumberFormat)[keyof typeof NumberFormat];
+    readonly separator?: (typeof PageNumberSeparator)[keyof typeof PageNumberSeparator];
 }
 export declare class PageNumberTypeAttributes extends XmlAttributeComponent<IPageNumberTypeAttributes> {
     protected readonly xmlKeys: {

package/build/file/document/body/section-properties/properties/page-size.d.ts

@@ -1,14 +1,14 @@
 import { XmlComponent } from '../../../../xml-components';
 import { PositiveUniversalMeasure } from '../../../../../util/values';
-export declare enum PageOrientation {
-    PORTRAIT = "portrait",
-    LANDSCAPE = "landscape"
-}
+export declare const PageOrientation: {
+    readonly PORTRAIT: "portrait";
+    readonly LANDSCAPE: "landscape";
+};
 export type IPageSizeAttributes = {
     readonly width?: number | PositiveUniversalMeasure;
     readonly height?: number | PositiveUniversalMeasure;
-    readonly orientation?: PageOrientation;
+    readonly orientation?: (typeof PageOrientation)[keyof typeof PageOrientation];
 };
 export declare class PageSize extends XmlComponent {
-    constructor(width: number | PositiveUniversalMeasure, height: number | PositiveUniversalMeasure, orientation: PageOrientation);
+    constructor(width: number | PositiveUniversalMeasure, height: number | PositiveUniversalMeasure, orientation: (typeof PageOrientation)[keyof typeof PageOrientation]);
 }

package/build/file/document/body/section-properties/properties/page-text-direction.d.ts

@@ -1,8 +1,8 @@
 import { XmlComponent } from '../../../../xml-components';
-export declare enum PageTextDirectionType {
-    LEFT_TO_RIGHT_TOP_TO_BOTTOM = "lrTb",
-    TOP_TO_BOTTOM_RIGHT_TO_LEFT = "tbRl"
-}
+export declare const PageTextDirectionType: {
+    readonly LEFT_TO_RIGHT_TOP_TO_BOTTOM: "lrTb";
+    readonly TOP_TO_BOTTOM_RIGHT_TO_LEFT: "tbRl";
+};
 export declare class PageTextDirection extends XmlComponent {
-    constructor(value: PageTextDirectionType);
+    constructor(value: (typeof PageTextDirectionType)[keyof typeof PageTextDirectionType]);
 }

package/build/file/document/body/section-properties/properties/section-type.d.ts

@@ -1,18 +1,18 @@
 import { XmlAttributeComponent, XmlComponent } from '../../../../xml-components';
-export declare enum SectionType {
-    NEXT_PAGE = "nextPage",
-    NEXT_COLUMN = "nextColumn",
-    CONTINUOUS = "continuous",
-    EVEN_PAGE = "evenPage",
-    ODD_PAGE = "oddPage"
-}
+export declare const SectionType: {
+    readonly NEXT_PAGE: "nextPage";
+    readonly NEXT_COLUMN: "nextColumn";
+    readonly CONTINUOUS: "continuous";
+    readonly EVEN_PAGE: "evenPage";
+    readonly ODD_PAGE: "oddPage";
+};
 export declare class SectionTypeAttributes extends XmlAttributeComponent<{
-    readonly val: SectionType;
+    readonly val: (typeof SectionType)[keyof typeof SectionType];
 }> {
     protected readonly xmlKeys: {
         val: string;
     };
 }
 export declare class Type extends XmlComponent {
-    constructor(value: SectionType);
+    constructor(value: (typeof SectionType)[keyof typeof SectionType]);
 }

package/build/file/document/body/section-properties/section-properties.d.ts

@@ -8,7 +8,7 @@ import { ILineNumberAttributes } from "./properties/line-number";
 import { IPageBordersOptions } from "./properties/page-borders";
 import { IPageMarginAttributes } from "./properties/page-margin";
 import { IPageNumberTypeAttributes } from "./properties/page-number";
-import { IPageSizeAttributes, PageOrientation } from "./properties/page-size";
+import { IPageSizeAttributes } from "./properties/page-size";
 import { PageTextDirectionType } from "./properties/page-text-direction";
 import { SectionType } from "./properties/section-type";
 export interface IHeaderFooterGroup<T> {
@@ -22,16 +22,16 @@ export interface ISectionPropertiesOptions {
         readonly margin?: IPageMarginAttributes;
         readonly pageNumbers?: IPageNumberTypeAttributes;
         readonly borders?: IPageBordersOptions;
-        readonly textDirection?: PageTextDirectionType;
+        readonly textDirection?: (typeof PageTextDirectionType)[keyof typeof PageTextDirectionType];
     };
     readonly grid?: IDocGridAttributesProperties;
     readonly headerWrapperGroup?: IHeaderFooterGroup<HeaderWrapper>;
     readonly footerWrapperGroup?: IHeaderFooterGroup<FooterWrapper>;
     readonly lineNumbers?: ILineNumberAttributes;
     readonly titlePage?: boolean;
-    readonly verticalAlign?: VerticalAlign;
+    readonly verticalAlign?: (typeof VerticalAlign)[keyof typeof VerticalAlign];
     readonly column?: IColumnsAttributes;
-    readonly type?: SectionType;
+    readonly type?: (typeof SectionType)[keyof typeof SectionType];
 }
 export declare const sectionMarginDefaults: {
     TOP: number;
@@ -45,7 +45,7 @@ export declare const sectionMarginDefaults: {
 export declare const sectionPageSizeDefaults: {
     WIDTH: number;
     HEIGHT: number;
-    ORIENTATION: PageOrientation;
+    ORIENTATION: "portrait";
 };
 export 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, }?: ISectionPropertiesOptions);

package/build/file/drawing/floating/align.d.ts

@@ -1,5 +1,5 @@
 import { HorizontalPositionAlign, VerticalPositionAlign } from '../../shared/alignment';
 import { XmlComponent } from '../../xml-components';
 export declare class Align extends XmlComponent {
-    constructor(value: HorizontalPositionAlign | VerticalPositionAlign);
+    constructor(value: (typeof HorizontalPositionAlign)[keyof typeof HorizontalPositionAlign] | (typeof VerticalPositionAlign)[keyof typeof VerticalPositionAlign]);
 }

package/build/file/drawing/floating/floating-position.d.ts

@@ -1,33 +1,33 @@
 import { HorizontalPositionAlign, VerticalPositionAlign } from '../../shared/alignment';
 import { ITextWrapping } from "../text-wrap";
-export declare enum HorizontalPositionRelativeFrom {
-    CHARACTER = "character",
-    COLUMN = "column",
-    INSIDE_MARGIN = "insideMargin",
-    LEFT_MARGIN = "leftMargin",
-    MARGIN = "margin",
-    OUTSIDE_MARGIN = "outsideMargin",
-    PAGE = "page",
-    RIGHT_MARGIN = "rightMargin"
-}
-export declare enum VerticalPositionRelativeFrom {
-    BOTTOM_MARGIN = "bottomMargin",
-    INSIDE_MARGIN = "insideMargin",
-    LINE = "line",
-    MARGIN = "margin",
-    OUTSIDE_MARGIN = "outsideMargin",
-    PAGE = "page",
-    PARAGRAPH = "paragraph",
-    TOP_MARGIN = "topMargin"
-}
+export 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";
+};
+export 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";
+};
 export interface IHorizontalPositionOptions {
-    readonly relative?: HorizontalPositionRelativeFrom;
-    readonly align?: HorizontalPositionAlign;
+    readonly relative?: (typeof HorizontalPositionRelativeFrom)[keyof typeof HorizontalPositionRelativeFrom];
+    readonly align?: (typeof HorizontalPositionAlign)[keyof typeof HorizontalPositionAlign];
     readonly offset?: number;
 }
 export interface IVerticalPositionOptions {
-    readonly relative?: VerticalPositionRelativeFrom;
-    readonly align?: VerticalPositionAlign;
+    readonly relative?: (typeof VerticalPositionRelativeFrom)[keyof typeof VerticalPositionRelativeFrom];
+    readonly align?: (typeof VerticalPositionAlign)[keyof typeof VerticalPositionAlign];
     readonly offset?: number;
 }
 export interface IMargins {

package/build/file/drawing/text-wrap/text-wrapping.d.ts

@@ -1,18 +1,18 @@
 import { IDistance } from "../drawing";
-export declare enum TextWrappingType {
-    NONE = 0,
-    SQUARE = 1,
-    TIGHT = 2,
-    TOP_AND_BOTTOM = 3
-}
-export declare enum TextWrappingSide {
-    BOTH_SIDES = "bothSides",
-    LEFT = "left",
-    RIGHT = "right",
-    LARGEST = "largest"
-}
+export declare const TextWrappingType: {
+    readonly NONE: 0;
+    readonly SQUARE: 1;
+    readonly TIGHT: 2;
+    readonly TOP_AND_BOTTOM: 3;
+};
+export declare const TextWrappingSide: {
+    readonly BOTH_SIDES: "bothSides";
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+    readonly LARGEST: "largest";
+};
 export interface ITextWrapping {
-    readonly type: TextWrappingType;
-    readonly side?: TextWrappingSide;
+    readonly type: (typeof TextWrappingType)[keyof typeof TextWrappingType];
+    readonly side?: (typeof TextWrappingSide)[keyof typeof TextWrappingSide];
     readonly margins?: IDistance;
 }

package/build/file/footer-wrapper.d.ts

@@ -8,7 +8,7 @@ import { Relationships } from "./relationships";
 import { Table } from "./table";
 export interface IDocumentFooter {
     readonly footer: FooterWrapper;
-    readonly type: HeaderFooterReferenceType;
+    readonly type: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType];
 }
 export declare class FooterWrapper implements IViewWrapper {
     private readonly media;

package/build/file/footnotes/footnote/footnote.d.ts

@@ -1,12 +1,12 @@
 import { Paragraph } from '../../paragraph';
 import { XmlComponent } from '../../xml-components';
-export declare enum FootnoteType {
-    SEPERATOR = "separator",
-    CONTINUATION_SEPERATOR = "continuationSeparator"
-}
+export declare const FootnoteType: {
+    readonly SEPERATOR: "separator";
+    readonly CONTINUATION_SEPERATOR: "continuationSeparator";
+};
 export interface IFootnoteOptions {
     readonly id: number;
-    readonly type?: FootnoteType;
+    readonly type?: (typeof FootnoteType)[keyof typeof FootnoteType];
     readonly children: readonly Paragraph[];
 }
 export declare class Footnote extends XmlComponent {

package/build/file/header-wrapper.d.ts

@@ -8,7 +8,7 @@ import { Relationships } from "./relationships";
 import { Table } from "./table";
 export interface IDocumentHeader {
     readonly header: HeaderWrapper;
-    readonly type: HeaderFooterReferenceType;
+    readonly type: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType];
 }
 export declare class HeaderWrapper implements IViewWrapper {
     private readonly media;