Change all project enums to objects with as const (#2445)

* feat: change all enums to as const objects

* Add word to dictionary

---------

Co-authored-by: Dolan Miu <dolan_miu@hotmail.com>

.cspell.json

@@ -17,6 +17,7 @@
         "dolan",
         "execa",
         "falsey",
+        "horz",
         "iife",
         "Initializable",
         "iroha",

src/export/packer/next-compiler.ts

@@ -44,7 +44,7 @@ export class Compiler {
         this.numberingReplacer = new NumberingReplacer();
     }
 
-    public compile(file: File, prettifyXml?: PrettifyType): JSZip {
+    public compile(file: File, prettifyXml?: (typeof PrettifyType)[keyof typeof PrettifyType]): JSZip {
         const zip = new JSZip();
         const xmlifiedFileMapping = this.xmlifyFile(file, prettifyXml);
         const map = new Map<string, IXmlifyedFile | readonly IXmlifyedFile[]>(Object.entries(xmlifiedFileMapping));
@@ -66,7 +66,7 @@ export class Compiler {
         return zip;
     }
 
-    private xmlifyFile(file: File, prettify?: PrettifyType): IXmlifyedFileMapping {
+    private xmlifyFile(file: File, prettify?: (typeof PrettifyType)[keyof typeof PrettifyType]): IXmlifyedFileMapping {
         const documentRelationshipCount = file.Document.Relationships.RelationshipCount + 1;
 
         const documentXmlData = xml(

src/export/packer/packer.ts

@@ -6,18 +6,21 @@ import { Compiler } from "./next-compiler";
 /**
  * Use blanks to prettify
  */
-export enum PrettifyType {
+export const PrettifyType = {
-    NONE = "",
+    NONE: "",
-    WITH_2_BLANKS = "  ",
+    WITH_2_BLANKS: "  ",
-    WITH_4_BLANKS = "    ",
+    WITH_4_BLANKS: "    ",
-    WITH_TAB = "\t",
+    // eslint-disable-next-line @typescript-eslint/naming-convention
-}
+    WITH_TAB: "\t",
+} as const;
 
-const convertPrettifyType = (prettify?: boolean | PrettifyType): PrettifyType | undefined =>
+const convertPrettifyType = (
+    prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType],
+): (typeof PrettifyType)[keyof typeof PrettifyType] | undefined =>
     prettify === true ? PrettifyType.WITH_2_BLANKS : prettify === false ? undefined : prettify;
 
 export class Packer {
-    public static async toString(file: File, prettify?: boolean | PrettifyType): Promise<string> {
+    public static async toString(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType]): Promise<string> {
         const zip = this.compiler.compile(file, convertPrettifyType(prettify));
         const zipData = await zip.generateAsync({
             type: "string",
@@ -28,7 +31,7 @@ export class Packer {
         return zipData;
     }
 
-    public static async toBuffer(file: File, prettify?: boolean | PrettifyType): Promise<Buffer> {
+    public static async toBuffer(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType]): Promise<Buffer> {
         const zip = this.compiler.compile(file, convertPrettifyType(prettify));
         const zipData = await zip.generateAsync({
             type: "nodebuffer",
@@ -39,7 +42,7 @@ export class Packer {
         return zipData;
     }
 
-    public static async toBase64String(file: File, prettify?: boolean | PrettifyType): Promise<string> {
+    public static async toBase64String(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType]): Promise<string> {
         const zip = this.compiler.compile(file, convertPrettifyType(prettify));
         const zipData = await zip.generateAsync({
             type: "base64",
@@ -50,7 +53,7 @@ export class Packer {
         return zipData;
     }
 
-    public static async toBlob(file: File, prettify?: boolean | PrettifyType): Promise<Blob> {
+    public static async toBlob(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType]): Promise<Blob> {
         const zip = this.compiler.compile(file, convertPrettifyType(prettify));
         const zipData = await zip.generateAsync({
             type: "blob",
@@ -61,7 +64,7 @@ export class Packer {
         return zipData;
     }
 
-    public static toStream(file: File, prettify?: boolean | PrettifyType): Stream {
+    public static toStream(file: File, prettify?: boolean | (typeof PrettifyType)[keyof typeof PrettifyType]): Stream {
         const stream = new Stream();
         const zip = this.compiler.compile(file, convertPrettifyType(prettify));
 

src/file/border/border.ts

@@ -23,7 +23,7 @@ import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 import { eighthPointMeasureValue, hexColorValue, pointMeasureValue } from "@util/values";
 
 export interface IBorderOptions {
-    readonly style: BorderStyle;
+    readonly style: (typeof BorderStyle)[keyof typeof BorderStyle];
     /** Border color, in hex (eg 'FF00AA') */
     readonly color?: string;
     /** Size of the border in 1/8 pt */
@@ -55,32 +55,34 @@ class BordersAttributes extends XmlAttributeComponent<IBorderOptions> {
     };
 }
 
-export enum BorderStyle {
+/* eslint-disable @typescript-eslint/naming-convention */
-    SINGLE = "single",
+export const BorderStyle = {
-    DASH_DOT_STROKED = "dashDotStroked",
+    SINGLE: "single",
-    DASHED = "dashed",
+    DASH_DOT_STROKED: "dashDotStroked",
-    DASH_SMALL_GAP = "dashSmallGap",
+    DASHED: "dashed",
-    DOT_DASH = "dotDash",
+    DASH_SMALL_GAP: "dashSmallGap",
-    DOT_DOT_DASH = "dotDotDash",
+    DOT_DASH: "dotDash",
-    DOTTED = "dotted",
+    DOT_DOT_DASH: "dotDotDash",
-    DOUBLE = "double",
+    DOTTED: "dotted",
-    DOUBLE_WAVE = "doubleWave",
+    DOUBLE: "double",
-    INSET = "inset",
+    DOUBLE_WAVE: "doubleWave",
-    NIL = "nil",
+    INSET: "inset",
-    NONE = "none",
+    NIL: "nil",
-    OUTSET = "outset",
+    NONE: "none",
-    THICK = "thick",
+    OUTSET: "outset",
-    THICK_THIN_LARGE_GAP = "thickThinLargeGap",
+    THICK: "thick",
-    THICK_THIN_MEDIUM_GAP = "thickThinMediumGap",
+    THICK_THIN_LARGE_GAP: "thickThinLargeGap",
-    THICK_THIN_SMALL_GAP = "thickThinSmallGap",
+    THICK_THIN_MEDIUM_GAP: "thickThinMediumGap",
-    THIN_THICK_LARGE_GAP = "thinThickLargeGap",
+    THICK_THIN_SMALL_GAP: "thickThinSmallGap",
-    THIN_THICK_MEDIUM_GAP = "thinThickMediumGap",
+    THIN_THICK_LARGE_GAP: "thinThickLargeGap",
-    THIN_THICK_SMALL_GAP = "thinThickSmallGap",
+    THIN_THICK_MEDIUM_GAP: "thinThickMediumGap",
-    THIN_THICK_THIN_LARGE_GAP = "thinThickThinLargeGap",
+    THIN_THICK_SMALL_GAP: "thinThickSmallGap",
-    THIN_THICK_THIN_MEDIUM_GAP = "thinThickThinMediumGap",
+    THIN_THICK_THIN_LARGE_GAP: "thinThickThinLargeGap",
-    THIN_THICK_THIN_SMALL_GAP = "thinThickThinSmallGap",
+    THIN_THICK_THIN_MEDIUM_GAP: "thinThickThinMediumGap",
-    THREE_D_EMBOSS = "threeDEmboss",
+    THIN_THICK_THIN_SMALL_GAP: "thinThickThinSmallGap",
-    THREE_D_ENGRAVE = "threeDEngrave",
+    THREE_D_EMBOSS: "threeDEmboss",
-    TRIPLE = "triple",
+    THREE_D_ENGRAVE: "threeDEngrave",
-    WAVE = "wave",
+    TRIPLE: "triple",
-}
+    WAVE: "wave",
+} as const;
+/* eslint-enable */

src/file/document/body/section-properties/properties/doc-grid.ts

@@ -17,14 +17,17 @@ import { decimalNumber } from "@util/values";
 //     <xsd:attribute name="charSpace" type="ST_DecimalNumber"/>
 // </xsd:complexType>
 
-export enum DocumentGridType {
+/* eslint-disable @typescript-eslint/naming-convention */
-    DEFAULT = "default",
+export const DocumentGridType = {
-    LINES = "lines",
+    DEFAULT: "default",
-    LINES_AND_CHARS = "linesAndChars",
+    LINES: "lines",
-    SNAP_TO_CHARS = "snapToChars",
+    LINES_AND_CHARS: "linesAndChars",
-}
+    SNAP_TO_CHARS: "snapToChars",
+} as const;
+
+/* eslint-enable */
 export interface IDocGridAttributesProperties {
-    readonly type?: DocumentGridType;
+    readonly type?: (typeof DocumentGridType)[keyof typeof DocumentGridType];
     readonly linePitch?: number;
     readonly charSpace?: number;
 }
@@ -38,7 +41,7 @@ export class DocGridAttributes extends XmlAttributeComponent<IDocGridAttributesP
 }
 
 export class DocumentGrid extends XmlComponent {
-    public constructor(linePitch: number, charSpace?: number, type?: DocumentGridType) {
+    public constructor(linePitch: number, charSpace?: number, type?: (typeof DocumentGridType)[keyof typeof DocumentGridType]) {
         super("w:docGrid");
 
         this.root.push(

src/file/document/body/section-properties/properties/header-footer-reference.ts

@@ -7,11 +7,11 @@ import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 //   <xsd:enumeration value="first"/>
 // </xsd:restriction>
 // </xsd:simpleType>
-export enum HeaderFooterReferenceType {
+export const HeaderFooterReferenceType = {
-    DEFAULT = "default",
+    DEFAULT: "default",
-    FIRST = "first",
+    FIRST: "first",
-    EVEN = "even",
+    EVEN: "even",
-}
+} as const;
 
 // </xsd:complexType>
 // <xsd:group name="EG_HdrFtrReferences">
@@ -33,12 +33,12 @@ export enum HeaderFooterReferenceType {
 // </xsd:complexType>
 
 export interface IHeaderFooterOptions {
-    readonly type?: HeaderFooterReferenceType;
+    readonly type?: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType];
     readonly id?: number;
 }
 
 class FooterReferenceAttributes extends XmlAttributeComponent<{
-    readonly type: HeaderFooterReferenceType;
+    readonly type: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType];
     readonly id: string;
 }> {
     protected readonly xmlKeys = {
@@ -47,12 +47,13 @@ class FooterReferenceAttributes extends XmlAttributeComponent<{
     };
 }
 
-export enum HeaderFooterType {
+export const HeaderFooterType = {
-    HEADER = "w:headerReference",
+    HEADER: "w:headerReference",
-    FOOTER = "w:footerReference",
+    FOOTER: "w:footerReference",
-}
+} as const;
+
 export class HeaderFooterReference extends XmlComponent {
-    public constructor(type: HeaderFooterType, options: IHeaderFooterOptions) {
+    public constructor(type: (typeof HeaderFooterType)[keyof typeof HeaderFooterType], options: IHeaderFooterOptions) {
         super(type);
 
         this.root.push(

src/file/document/body/section-properties/properties/line-number.ts

@@ -9,11 +9,14 @@ import { decimalNumber, PositiveUniversalMeasure, twipsMeasureValue } from "@uti
 //   <xsd:enumeration value="continuous"/>
 // </xsd:restriction>
 // </xsd:simpleType>
-export enum LineNumberRestartFormat {
+
-    NEW_PAGE = "newPage",
+/* eslint-disable @typescript-eslint/naming-convention */
-    NEW_SECTION = "newSection",
+export const LineNumberRestartFormat = {
-    CONTINUOUS = "continuous",
+    NEW_PAGE: "newPage",
-}
+    NEW_SECTION: "newSection",
+    CONTINUOUS: "continuous",
+} as const;
+/* eslint-enable */
 
 // <xsd:complexType name="CT_LineNumber">
 //     <xsd:attribute name="countBy" type="ST_DecimalNumber" use="optional"/>
@@ -25,7 +28,7 @@ export enum LineNumberRestartFormat {
 export interface ILineNumberAttributes {
     readonly countBy?: number;
     readonly start?: number;
-    readonly restart?: LineNumberRestartFormat;
+    readonly restart?: (typeof LineNumberRestartFormat)[keyof typeof LineNumberRestartFormat];
     readonly distance?: number | PositiveUniversalMeasure;
 }
 
@@ -36,13 +39,16 @@ export class LineNumberType extends XmlComponent {
             new NextAttributeComponent<{
                 readonly countBy?: number;
                 readonly start?: number;
-                readonly restart?: LineNumberRestartFormat;
+                readonly restart?: (typeof LineNumberRestartFormat)[keyof typeof LineNumberRestartFormat];
                 readonly distance?: number | PositiveUniversalMeasure;
             }>({
                 countBy: { key: "w:countBy", value: countBy === undefined ? undefined : decimalNumber(countBy) },
                 start: { key: "w:start", value: start === undefined ? undefined : decimalNumber(start) },
                 restart: { key: "w:restart", value: restart },
-                distance: { key: "w:distance", value: distance === undefined ? undefined : twipsMeasureValue(distance) },
+                distance: {
+                    key: "w:distance",
+                    value: distance === undefined ? undefined : twipsMeasureValue(distance),
+                },
             }),
         );
     }

src/file/document/body/section-properties/properties/page-borders.ts

@@ -9,11 +9,14 @@ import { IgnoreIfEmptyXmlComponent, XmlAttributeComponent } from "@file/xml-comp
 //   <xsd:enumeration value="notFirstPage"/>
 // </xsd:restriction>
 // </xsd:simpleType>
-export enum PageBorderDisplay {
+
-    ALL_PAGES = "allPages",
+/* eslint-disable @typescript-eslint/naming-convention */
-    FIRST_PAGE = "firstPage",
+export const PageBorderDisplay = {
-    NOT_FIRST_PAGE = "notFirstPage",
+    ALL_PAGES: "allPages",
-}
+    FIRST_PAGE: "firstPage",
+    NOT_FIRST_PAGE: "notFirstPage",
+} as const;
+/* eslint-enable */
 
 // <xsd:simpleType name="ST_PageBorderOffset">
 // <xsd:restriction base="xsd:string">
@@ -21,10 +24,10 @@ export enum PageBorderDisplay {
 //   <xsd:enumeration value="text"/>
 // </xsd:restriction>
 // </xsd:simpleType>
-export enum PageBorderOffsetFrom {
+export const PageBorderOffsetFrom = {
-    PAGE = "page",
+    PAGE: "page",
-    TEXT = "text",
+    TEXT: "text",
-}
+} as const;
 
 // <xsd:simpleType name="ST_PageBorderZOrder">
 // <xsd:restriction base="xsd:string">
@@ -32,15 +35,15 @@ export enum PageBorderOffsetFrom {
 //   <xsd:enumeration value="back"/>
 // </xsd:restriction>
 // </xsd:simpleType>
-export enum PageBorderZOrder {
+export const PageBorderZOrder = {
-    BACK = "back",
+    BACK: "back",
-    FRONT = "front",
+    FRONT: "front",
-}
+} as const;
 
 export interface IPageBorderAttributes {
-    readonly display?: PageBorderDisplay;
+    readonly display?: (typeof PageBorderDisplay)[keyof typeof PageBorderDisplay];
-    readonly offsetFrom?: PageBorderOffsetFrom;
+    readonly offsetFrom?: (typeof PageBorderOffsetFrom)[keyof typeof PageBorderOffsetFrom];
-    readonly zOrder?: PageBorderZOrder;
+    readonly zOrder?: (typeof PageBorderZOrder)[keyof typeof PageBorderZOrder];
 }
 
 export interface IPageBordersOptions {

src/file/document/body/section-properties/properties/page-number.ts

@@ -12,18 +12,22 @@ import { decimalNumber } from "@util/values";
 //   <xsd:enumeration value="enDash"/>
 // </xsd:restriction>
 // </xsd:simpleType>
-export enum PageNumberSeparator {
+
-    HYPHEN = "hyphen",
+/* eslint-disable @typescript-eslint/naming-convention */
-    PERIOD = "period",
+export const PageNumberSeparator = {
-    COLON = "colon",
+    HYPHEN: "hyphen",
-    EM_DASH = "emDash",
+    PERIOD: "period",
-    EN_DASH = "endash",
+    COLON: "colon",
-}
+    EM_DASH: "emDash",
+    EN_DASH: "endash",
+} as const;
+
+/* eslint-enable */
 
 export interface IPageNumberTypeAttributes {
     readonly start?: number;
-    readonly formatType?: NumberFormat;
+    readonly formatType?: (typeof NumberFormat)[keyof typeof NumberFormat];
-    readonly separator?: PageNumberSeparator;
+    readonly separator?: (typeof PageNumberSeparator)[keyof typeof PageNumberSeparator];
 }
 
 // <xsd:complexType name="CT_PageNumber">
@@ -40,6 +44,7 @@ export class PageNumberTypeAttributes extends XmlAttributeComponent<IPageNumberT
         separator: "w:chapSep",
     };
 }
+
 export class PageNumberType extends XmlComponent {
     public constructor({ start, formatType, separator }: IPageNumberTypeAttributes) {
         super("w:pgNumType");

src/file/document/body/section-properties/properties/page-size.ts

@@ -7,10 +7,10 @@ import { PositiveUniversalMeasure, twipsMeasureValue } from "@util/values";
 //   <xsd:enumeration value="landscape"/>
 // </xsd:restriction>
 // </xsd:simpleType>
-export enum PageOrientation {
+export const PageOrientation = {
-    PORTRAIT = "portrait",
+    PORTRAIT: "portrait",
-    LANDSCAPE = "landscape",
+    LANDSCAPE: "landscape",
-}
+} as const;
 
 // <xsd:complexType name="CT_PageSz">
 //     <xsd:attribute name="w" type="s:ST_TwipsMeasure"/>
@@ -21,11 +21,15 @@ export enum PageOrientation {
 export type IPageSizeAttributes = {
     readonly width?: number | PositiveUniversalMeasure;
     readonly height?: number | PositiveUniversalMeasure;
-    readonly orientation?: PageOrientation;
+    readonly orientation?: (typeof PageOrientation)[keyof typeof PageOrientation];
 };
 
 export class PageSize extends XmlComponent {
-    public constructor(width: number | PositiveUniversalMeasure, height: number | PositiveUniversalMeasure, orientation: PageOrientation) {
+    public constructor(
+        width: number | PositiveUniversalMeasure,
+        height: number | PositiveUniversalMeasure,
+        orientation: (typeof PageOrientation)[keyof typeof PageOrientation],
+    ) {
         super("w:pgSz");
 
         const flip = orientation === PageOrientation.LANDSCAPE;

src/file/document/body/section-properties/properties/page-text-direction.ts

@@ -1,16 +1,21 @@
 import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 
-export enum PageTextDirectionType {
+/* eslint-disable @typescript-eslint/naming-convention */
-    LEFT_TO_RIGHT_TOP_TO_BOTTOM = "lrTb",
+export const PageTextDirectionType = {
-    TOP_TO_BOTTOM_RIGHT_TO_LEFT = "tbRl",
+    LEFT_TO_RIGHT_TOP_TO_BOTTOM: "lrTb",
-}
+    TOP_TO_BOTTOM_RIGHT_TO_LEFT: "tbRl",
+} as const;
 
-class PageTextDirectionAttributes extends XmlAttributeComponent<{ readonly val: PageTextDirectionType }> {
+/* eslint-enable */
+
+class PageTextDirectionAttributes extends XmlAttributeComponent<{
+    readonly val: (typeof PageTextDirectionType)[keyof typeof PageTextDirectionType];
+}> {
     protected readonly xmlKeys = { val: "w:val" };
 }
 
 export class PageTextDirection extends XmlComponent {
-    public constructor(value: PageTextDirectionType) {
+    public constructor(value: (typeof PageTextDirectionType)[keyof typeof PageTextDirectionType]) {
         super("w:textDirection");
 
         this.root.push(

src/file/document/body/section-properties/properties/section-type.ts

@@ -10,19 +10,22 @@ import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 //   <xsd:enumeration value="oddPage"/>
 // </xsd:restriction>
 // </xsd:simpleType>
-export enum SectionType {
+
-    NEXT_PAGE = "nextPage",
+/* eslint-disable @typescript-eslint/naming-convention */
-    NEXT_COLUMN = "nextColumn",
+export const SectionType = {
-    CONTINUOUS = "continuous",
+    NEXT_PAGE: "nextPage",
-    EVEN_PAGE = "evenPage",
+    NEXT_COLUMN: "nextColumn",
-    ODD_PAGE = "oddPage",
+    CONTINUOUS: "continuous",
-}
+    EVEN_PAGE: "evenPage",
+    ODD_PAGE: "oddPage",
+} as const;
+/* eslint-enable */
 
 // <xsd:complexType name="CT_SectType">
 //     <xsd:attribute name="val" type="ST_SectionMark"/>
 // </xsd:complexType>
 export class SectionTypeAttributes extends XmlAttributeComponent<{
-    readonly val: SectionType;
+    readonly val: (typeof SectionType)[keyof typeof SectionType];
 }> {
     protected readonly xmlKeys = {
         val: "w:val",
@@ -30,7 +33,7 @@ export class SectionTypeAttributes extends XmlAttributeComponent<{
 }
 
 export class Type extends XmlComponent {
-    public constructor(value: SectionType) {
+    public constructor(value: (typeof SectionType)[keyof typeof SectionType]) {
         super("w:type");
         this.root.push(new SectionTypeAttributes({ val: value }));
     }

src/file/document/body/section-properties/section-properties.ts

@@ -29,16 +29,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];
 }
 
 // <xsd:complexType name="CT_SectPr">
@@ -162,7 +162,7 @@ export class SectionProperties extends XmlComponent {
     }
 
     private addHeaderFooterGroup(
-        type: HeaderFooterType,
+        type: (typeof HeaderFooterType)[keyof typeof HeaderFooterType],
         group: IHeaderFooterGroup<HeaderWrapper> | IHeaderFooterGroup<FooterWrapper>,
     ): void {
         if (group.default) {

src/file/drawing/floating/align.ts

@@ -3,7 +3,11 @@ import { HorizontalPositionAlign, VerticalPositionAlign } from "@file/shared/ali
 import { XmlComponent } from "@file/xml-components";
 
 export class Align extends XmlComponent {
-    public constructor(value: HorizontalPositionAlign | VerticalPositionAlign) {
+    public constructor(
+        value:
+            | (typeof HorizontalPositionAlign)[keyof typeof HorizontalPositionAlign]
+            | (typeof VerticalPositionAlign)[keyof typeof VerticalPositionAlign],
+    ) {
         super("wp:align");
         this.root.push(value);
     }

src/file/drawing/floating/floating-position.ts

@@ -4,37 +4,39 @@ import { HorizontalPositionAlign, VerticalPositionAlign } from "@file/shared/ali
 
 import { ITextWrapping } from "../text-wrap";
 
-export enum HorizontalPositionRelativeFrom {
+/* eslint-disable @typescript-eslint/naming-convention */
-    CHARACTER = "character",
+export const HorizontalPositionRelativeFrom = {
-    COLUMN = "column",
+    CHARACTER: "character",
-    INSIDE_MARGIN = "insideMargin",
+    COLUMN: "column",
-    LEFT_MARGIN = "leftMargin",
+    INSIDE_MARGIN: "insideMargin",
-    MARGIN = "margin",
+    LEFT_MARGIN: "leftMargin",
-    OUTSIDE_MARGIN = "outsideMargin",
+    MARGIN: "margin",
-    PAGE = "page",
+    OUTSIDE_MARGIN: "outsideMargin",
-    RIGHT_MARGIN = "rightMargin",
+    PAGE: "page",
-}
+    RIGHT_MARGIN: "rightMargin",
+} as const;
 
-export enum VerticalPositionRelativeFrom {
+export const VerticalPositionRelativeFrom = {
-    BOTTOM_MARGIN = "bottomMargin",
+    BOTTOM_MARGIN: "bottomMargin",
-    INSIDE_MARGIN = "insideMargin",
+    INSIDE_MARGIN: "insideMargin",
-    LINE = "line",
+    LINE: "line",
-    MARGIN = "margin",
+    MARGIN: "margin",
-    OUTSIDE_MARGIN = "outsideMargin",
+    OUTSIDE_MARGIN: "outsideMargin",
-    PAGE = "page",
+    PAGE: "page",
-    PARAGRAPH = "paragraph",
+    PARAGRAPH: "paragraph",
-    TOP_MARGIN = "topMargin",
+    TOP_MARGIN: "topMargin",
-}
+} as const;
 
+/* eslint-enable */
 export interface IHorizontalPositionOptions {
-    readonly relative?: HorizontalPositionRelativeFrom;
+    readonly relative?: (typeof HorizontalPositionRelativeFrom)[keyof typeof HorizontalPositionRelativeFrom];
-    readonly align?: HorizontalPositionAlign;
+    readonly align?: (typeof HorizontalPositionAlign)[keyof typeof HorizontalPositionAlign];
     readonly offset?: number;
 }
 
 export interface IVerticalPositionOptions {
-    readonly relative?: VerticalPositionRelativeFrom;
+    readonly relative?: (typeof VerticalPositionRelativeFrom)[keyof typeof VerticalPositionRelativeFrom];
-    readonly align?: VerticalPositionAlign;
+    readonly align?: (typeof VerticalPositionAlign)[keyof typeof VerticalPositionAlign];
     readonly offset?: number;
 }
 

src/file/drawing/floating/horizontal-position.ts

@@ -5,7 +5,7 @@ import { HorizontalPositionRelativeFrom, IHorizontalPositionOptions } from "./fl
 import { PositionOffset } from "./position-offset";
 
 class HorizontalPositionAttributes extends XmlAttributeComponent<{
-    readonly relativeFrom: HorizontalPositionRelativeFrom;
+    readonly relativeFrom: (typeof HorizontalPositionRelativeFrom)[keyof typeof HorizontalPositionRelativeFrom];
 }> {
     protected readonly xmlKeys = {
         relativeFrom: "relativeFrom",

src/file/drawing/floating/vertical-position.ts

@@ -5,7 +5,7 @@ import { IVerticalPositionOptions, VerticalPositionRelativeFrom } from "./floati
 import { PositionOffset } from "./position-offset";
 
 class VerticalPositionAttributes extends XmlAttributeComponent<{
-    readonly relativeFrom: VerticalPositionRelativeFrom;
+    readonly relativeFrom: (typeof VerticalPositionRelativeFrom)[keyof typeof VerticalPositionRelativeFrom];
 }> {
     protected readonly xmlKeys = {
         relativeFrom: "relativeFrom",

src/file/drawing/text-wrap/text-wrapping.ts

@@ -1,22 +1,25 @@
 // http://officeopenxml.com/drwPicFloating-textWrap.php
 import { IDistance } from "../drawing";
 
-export enum TextWrappingType {
+/* eslint-disable @typescript-eslint/naming-convention */
-    NONE,
+export const TextWrappingType = {
-    SQUARE,
+    NONE: 0,
-    TIGHT,
+    SQUARE: 1,
-    TOP_AND_BOTTOM,
+    TIGHT: 2,
-}
+    TOP_AND_BOTTOM: 3,
+} as const;
 
-export enum TextWrappingSide {
+export const TextWrappingSide = {
-    BOTH_SIDES = "bothSides",
+    BOTH_SIDES: "bothSides",
-    LEFT = "left",
+    LEFT: "left",
-    RIGHT = "right",
+    RIGHT: "right",
-    LARGEST = "largest",
+    LARGEST: "largest",
-}
+} as const;
+
+/* eslint-enable */
 
 export interface ITextWrapping {
-    readonly type: TextWrappingType;
+    readonly type: (typeof TextWrappingType)[keyof typeof TextWrappingType];
-    readonly side?: TextWrappingSide;
+    readonly side?: (typeof TextWrappingSide)[keyof typeof TextWrappingSide];
     readonly margins?: IDistance;
 }

src/file/drawing/text-wrap/wrap-square.ts

@@ -6,7 +6,7 @@ import { IMargins } from "../floating";
 import { ITextWrapping, TextWrappingSide } from "./text-wrapping";
 
 interface IWrapSquareAttributes extends IDistance {
-    readonly wrapText?: TextWrappingSide;
+    readonly wrapText?: (typeof TextWrappingSide)[keyof typeof TextWrappingSide];
 }
 
 class WrapSquareAttributes extends XmlAttributeComponent<IWrapSquareAttributes> {

src/file/file.ts

@@ -154,7 +154,10 @@ export class File {
         return wrapper;
     }
 
-    private addHeaderToDocument(header: HeaderWrapper, type: HeaderFooterReferenceType = HeaderFooterReferenceType.DEFAULT): void {
+    private addHeaderToDocument(
+        header: HeaderWrapper,
+        type: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType] = HeaderFooterReferenceType.DEFAULT,
+    ): void {
         // eslint-disable-next-line functional/immutable-data
         this.headers.push({ header, type });
         this.documentWrapper.Relationships.createRelationship(
@@ -165,7 +168,10 @@ export class File {
         this.contentTypes.addHeader(this.headers.length);
     }
 
-    private addFooterToDocument(footer: FooterWrapper, type: HeaderFooterReferenceType = HeaderFooterReferenceType.DEFAULT): void {
+    private addFooterToDocument(
+        footer: FooterWrapper,
+        type: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType] = HeaderFooterReferenceType.DEFAULT,
+    ): void {
         // eslint-disable-next-line functional/immutable-data
         this.footers.push({ footer, type });
         this.documentWrapper.Relationships.createRelationship(

src/file/footer-wrapper.ts

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

src/file/footnotes/footnote/footnote.ts

@@ -4,14 +4,15 @@ import { XmlComponent } from "@file/xml-components";
 import { FootnoteAttributes } from "./footnote-attributes";
 import { FootnoteRefRun } from "./run/footnote-ref-run";
 
-export enum FootnoteType {
+export const FootnoteType = {
-    SEPERATOR = "separator",
+    SEPERATOR: "separator",
-    CONTINUATION_SEPERATOR = "continuationSeparator",
+    // eslint-disable-next-line @typescript-eslint/naming-convention
-}
+    CONTINUATION_SEPERATOR: "continuationSeparator",
+} as const;
 
 export interface IFootnoteOptions {
     readonly id: number;
-    readonly type?: FootnoteType;
+    readonly type?: (typeof FootnoteType)[keyof typeof FootnoteType];
     readonly children: readonly Paragraph[];
 }
 

src/file/header-wrapper.ts

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

src/file/numbering/level.ts

@@ -75,71 +75,75 @@ import { IRunStylePropertiesOptions, RunProperties } from "../paragraph/run/prop
 //         <xsd:enumeration value="custom"/>
 //     </xsd:restriction>
 // </xsd:simpleType>
-export enum LevelFormat {
+
-    DECIMAL = "decimal",
+/* eslint-disable @typescript-eslint/naming-convention */
-    UPPER_ROMAN = "upperRoman",
+export const LevelFormat = {
-    LOWER_ROMAN = "lowerRoman",
+    DECIMAL: "decimal",
-    UPPER_LETTER = "upperLetter",
+    UPPER_ROMAN: "upperRoman",
-    LOWER_LETTER = "lowerLetter",
+    LOWER_ROMAN: "lowerRoman",
-    ORDINAL = "ordinal",
+    UPPER_LETTER: "upperLetter",
-    CARDINAL_TEXT = "cardinalText",
+    LOWER_LETTER: "lowerLetter",
-    ORDINAL_TEXT = "ordinalText",
+    ORDINAL: "ordinal",
-    HEX = "hex",
+    CARDINAL_TEXT: "cardinalText",
-    CHICAGO = "chicago",
+    ORDINAL_TEXT: "ordinalText",
-    IDEOGRAPH__DIGITAL = "ideographDigital",
+    HEX: "hex",
-    JAPANESE_COUNTING = "japaneseCounting",
+    CHICAGO: "chicago",
-    AIUEO = "aiueo",
+    IDEOGRAPH__DIGITAL: "ideographDigital",
-    IROHA = "iroha",
+    JAPANESE_COUNTING: "japaneseCounting",
-    DECIMAL_FULL_WIDTH = "decimalFullWidth",
+    AIUEO: "aiueo",
-    DECIMAL_HALF_WIDTH = "decimalHalfWidth",
+    IROHA: "iroha",
-    JAPANESE_LEGAL = "japaneseLegal",
+    DECIMAL_FULL_WIDTH: "decimalFullWidth",
-    JAPANESE_DIGITAL_TEN_THOUSAND = "japaneseDigitalTenThousand",
+    DECIMAL_HALF_WIDTH: "decimalHalfWidth",
-    DECIMAL_ENCLOSED_CIRCLE = "decimalEnclosedCircle",
+    JAPANESE_LEGAL: "japaneseLegal",
-    DECIMAL_FULL_WIDTH2 = "decimalFullWidth2",
+    JAPANESE_DIGITAL_TEN_THOUSAND: "japaneseDigitalTenThousand",
-    AIUEO_FULL_WIDTH = "aiueoFullWidth",
+    DECIMAL_ENCLOSED_CIRCLE: "decimalEnclosedCircle",
-    IROHA_FULL_WIDTH = "irohaFullWidth",
+    DECIMAL_FULL_WIDTH2: "decimalFullWidth2",
-    DECIMAL_ZERO = "decimalZero",
+    AIUEO_FULL_WIDTH: "aiueoFullWidth",
-    BULLET = "bullet",
+    IROHA_FULL_WIDTH: "irohaFullWidth",
-    GANADA = "ganada",
+    DECIMAL_ZERO: "decimalZero",
-    CHOSUNG = "chosung",
+    BULLET: "bullet",
-    DECIMAL_ENCLOSED_FULLSTOP = "decimalEnclosedFullstop",
+    GANADA: "ganada",
-    DECIMAL_ENCLOSED_PARENTHESES = "decimalEnclosedParen",
+    CHOSUNG: "chosung",
-    DECIMAL_ENCLOSED_CIRCLE_CHINESE = "decimalEnclosedCircleChinese",
+    DECIMAL_ENCLOSED_FULLSTOP: "decimalEnclosedFullstop",
-    IDEOGRAPH_ENCLOSED_CIRCLE = "ideographEnclosedCircle",
+    DECIMAL_ENCLOSED_PARENTHESES: "decimalEnclosedParen",
-    IDEOGRAPH_TRADITIONAL = "ideographTraditional",
+    DECIMAL_ENCLOSED_CIRCLE_CHINESE: "decimalEnclosedCircleChinese",
-    IDEOGRAPH_ZODIAC = "ideographZodiac",
+    IDEOGRAPH_ENCLOSED_CIRCLE: "ideographEnclosedCircle",
-    IDEOGRAPH_ZODIAC_TRADITIONAL = "ideographZodiacTraditional",
+    IDEOGRAPH_TRADITIONAL: "ideographTraditional",
-    TAIWANESE_COUNTING = "taiwaneseCounting",
+    IDEOGRAPH_ZODIAC: "ideographZodiac",
-    IDEOGRAPH_LEGAL_TRADITIONAL = "ideographLegalTraditional",
+    IDEOGRAPH_ZODIAC_TRADITIONAL: "ideographZodiacTraditional",
-    TAIWANESE_COUNTING_THOUSAND = "taiwaneseCountingThousand",
+    TAIWANESE_COUNTING: "taiwaneseCounting",
-    TAIWANESE_DIGITAL = "taiwaneseDigital",
+    IDEOGRAPH_LEGAL_TRADITIONAL: "ideographLegalTraditional",
-    CHINESE_COUNTING = "chineseCounting",
+    TAIWANESE_COUNTING_THOUSAND: "taiwaneseCountingThousand",
-    CHINESE_LEGAL_SIMPLIFIED = "chineseLegalSimplified",
+    TAIWANESE_DIGITAL: "taiwaneseDigital",
-    CHINESE_COUNTING_THOUSAND = "chineseCountingThousand",
+    CHINESE_COUNTING: "chineseCounting",
-    KOREAN_DIGITAL = "koreanDigital",
+    CHINESE_LEGAL_SIMPLIFIED: "chineseLegalSimplified",
-    KOREAN_COUNTING = "koreanCounting",
+    CHINESE_COUNTING_THOUSAND: "chineseCountingThousand",
-    KOREAN_LEGAL = "koreanLegal",
+    KOREAN_DIGITAL: "koreanDigital",
-    KOREAN_DIGITAL2 = "koreanDigital2",
+    KOREAN_COUNTING: "koreanCounting",
-    VIETNAMESE_COUNTING = "vietnameseCounting",
+    KOREAN_LEGAL: "koreanLegal",
-    RUSSIAN_LOWER = "russianLower",
+    KOREAN_DIGITAL2: "koreanDigital2",
-    RUSSIAN_UPPER = "russianUpper",
+    VIETNAMESE_COUNTING: "vietnameseCounting",
-    NONE = "none",
+    RUSSIAN_LOWER: "russianLower",
-    NUMBER_IN_DASH = "numberInDash",
+    RUSSIAN_UPPER: "russianUpper",
-    HEBREW1 = "hebrew1",
+    NONE: "none",
-    HEBREW2 = "hebrew2",
+    NUMBER_IN_DASH: "numberInDash",
-    ARABIC_ALPHA = "arabicAlpha",
+    HEBREW1: "hebrew1",
-    ARABIC_ABJAD = "arabicAbjad",
+    HEBREW2: "hebrew2",
-    HINDI_VOWELS = "hindiVowels",
+    ARABIC_ALPHA: "arabicAlpha",
-    HINDI_CONSONANTS = "hindiConsonants",
+    ARABIC_ABJAD: "arabicAbjad",
-    HINDI_NUMBERS = "hindiNumbers",
+    HINDI_VOWELS: "hindiVowels",
-    HINDI_COUNTING = "hindiCounting",
+    HINDI_CONSONANTS: "hindiConsonants",
-    THAI_LETTERS = "thaiLetters",
+    HINDI_NUMBERS: "hindiNumbers",
-    THAI_NUMBERS = "thaiNumbers",
+    HINDI_COUNTING: "hindiCounting",
-    THAI_COUNTING = "thaiCounting",
+    THAI_LETTERS: "thaiLetters",
-    BAHT_TEXT = "bahtText",
+    THAI_NUMBERS: "thaiNumbers",
-    DOLLAR_TEXT = "dollarText",
+    THAI_COUNTING: "thaiCounting",
-    CUSTOM = "custom",
+    BAHT_TEXT: "bahtText",
-}
+    DOLLAR_TEXT: "dollarText",
+    CUSTOM: "custom",
+} as const;
+
+/* eslint-enable */
 
 class LevelAttributes extends XmlAttributeComponent<{
     readonly ilvl?: number;
@@ -182,7 +186,7 @@ class LevelText extends XmlComponent {
 }
 
 class LevelJc extends XmlComponent {
-    public constructor(value: AlignmentType) {
+    public constructor(value: (typeof AlignmentType)[keyof typeof AlignmentType]) {
         super("w:lvlJc");
         this.root.push(
             new Attributes({
@@ -192,19 +196,19 @@ class LevelJc extends XmlComponent {
     }
 }
 
-export enum LevelSuffix {
+export const LevelSuffix = {
-    NOTHING = "nothing",
+    NOTHING: "nothing",
-    SPACE = "space",
+    SPACE: "space",
-    TAB = "tab",
+    TAB: "tab",
-}
+} as const;
 
 export interface ILevelsOptions {
     readonly level: number;
-    readonly format?: LevelFormat;
+    readonly format?: (typeof LevelFormat)[keyof typeof LevelFormat];
     readonly text?: string;
-    readonly alignment?: AlignmentType;
+    readonly alignment?: (typeof AlignmentType)[keyof typeof AlignmentType];
     readonly start?: number;
-    readonly suffix?: LevelSuffix;
+    readonly suffix?: (typeof LevelSuffix)[keyof typeof LevelSuffix];
     readonly isLegalNumberingStyle?: boolean;
     readonly style?: {
         readonly run?: IRunStylePropertiesOptions;
@@ -223,7 +227,7 @@ export interface ILevelsOptions {
 //         </xsd:restriction>
 //     </xsd:simpleType>
 class Suffix extends XmlComponent {
-    public constructor(value: LevelSuffix) {
+    public constructor(value: (typeof LevelSuffix)[keyof typeof LevelSuffix]) {
         super("w:suff");
         this.root.push(
             new Attributes({

src/file/paragraph/formatting/alignment.ts

@@ -19,41 +19,47 @@ import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 //         <xsd:enumeration value="right"/>
 //     </xsd:restriction>
 // </xsd:simpleType>
-export enum AlignmentType {
-    /** Align Start */
-    START = "start",
-    /** Align Center */
-    CENTER = "center",
-    /** End */
-    END = "end",
-    /** Justified */
-    BOTH = "both",
-    /** Medium Kashida Length */
-    MEDIUM_KASHIDA = "mediumKashida",
-    /** Distribute All Characters Equally */
-    DISTRIBUTE = "distribute",
-    /** Align to List Tab */
-    NUM_TAB = "numTab",
-    /** Widest Kashida Length */
-    HIGH_KASHIDA = "highKashida",
-    /** Low Kashida Length */
-    LOW_KASHIDA = "lowKashida",
-    /** Thai Language Justification */
-    THAI_DISTRIBUTE = "thaiDistribute",
-    /** Align Left */
-    LEFT = "left",
-    /** Align Right */
-    RIGHT = "right",
-    /** Justified */
-    JUSTIFIED = "both",
-}
 
-export class AlignmentAttributes extends XmlAttributeComponent<{ readonly val: AlignmentType }> {
+/* eslint-disable @typescript-eslint/naming-convention */
+export const AlignmentType = {
+    /** Align Start */
+    START: "start",
+    /** Align Center */
+    CENTER: "center",
+    /** End */
+    END: "end",
+    /** Justified */
+    BOTH: "both",
+    /** Medium Kashida Length */
+    MEDIUM_KASHIDA: "mediumKashida",
+    /** Distribute All Characters Equally */
+    DISTRIBUTE: "distribute",
+    /** Align to List Tab */
+    NUM_TAB: "numTab",
+    /** Widest Kashida Length */
+    HIGH_KASHIDA: "highKashida",
+    /** Low Kashida Length */
+    LOW_KASHIDA: "lowKashida",
+    /** Thai Language Justification */
+    THAI_DISTRIBUTE: "thaiDistribute",
+    /** Align Left */
+    LEFT: "left",
+    /** Align Right */
+    RIGHT: "right",
+    /** Justified */
+    JUSTIFIED: "both",
+} as const;
+
+/* eslint-enable */
+
+export class AlignmentAttributes extends XmlAttributeComponent<{
+    readonly val: (typeof AlignmentType)[keyof typeof AlignmentType];
+}> {
     protected readonly xmlKeys = { val: "w:val" };
 }
 
 export class Alignment extends XmlComponent {
-    public constructor(type: AlignmentType) {
+    public constructor(type: (typeof AlignmentType)[keyof typeof AlignmentType]) {
         super("w:jc");
         this.root.push(new AlignmentAttributes({ val: type }));
     }

src/file/paragraph/formatting/break.ts

@@ -2,14 +2,14 @@
 import { Attributes, XmlComponent } from "@file/xml-components";
 import { Run } from "../run";
 
-enum BreakType {
+const BreakType = {
-    COLUMN = "column",
+    COLUMN: "column",
-    PAGE = "page",
+    PAGE: "page",
     // textWrapping breaks are the default and already exposed via the "Run" class
-}
+} as const;
 
 class Break extends XmlComponent {
-    public constructor(type: BreakType) {
+    public constructor(type: (typeof BreakType)[keyof typeof BreakType]) {
         super("w:br");
         this.root.push(
             new Attributes({

src/file/paragraph/formatting/spacing.ts

@@ -1,17 +1,19 @@
 // http://officeopenxml.com/WPspacing.php
 import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 
-export enum LineRuleType {
+export const LineRuleType = {
-    AT_LEAST = "atLeast",
+    // eslint-disable-next-line @typescript-eslint/naming-convention
-    EXACTLY = "exactly",
+    AT_LEAST: "atLeast",
-    EXACT = "exact",
+    EXACTLY: "exactly",
-    AUTO = "auto",
+    EXACT: "exact",
-}
+    AUTO: "auto",
+} as const;
+
 export interface ISpacingProperties {
     readonly after?: number;
     readonly before?: number;
     readonly line?: number;
-    readonly lineRule?: LineRuleType;
+    readonly lineRule?: (typeof LineRuleType)[keyof typeof LineRuleType];
     readonly beforeAutoSpacing?: boolean;
     readonly afterAutoSpacing?: boolean;
 }

src/file/paragraph/formatting/style.ts

@@ -1,14 +1,14 @@
 import { Attributes, XmlComponent } from "@file/xml-components";
 
-export enum HeadingLevel {
+export const HeadingLevel = {
-    HEADING_1 = "Heading1",
+    HEADING_1: "Heading1",
-    HEADING_2 = "Heading2",
+    HEADING_2: "Heading2",
-    HEADING_3 = "Heading3",
+    HEADING_3: "Heading3",
-    HEADING_4 = "Heading4",
+    HEADING_4: "Heading4",
-    HEADING_5 = "Heading5",
+    HEADING_5: "Heading5",
-    HEADING_6 = "Heading6",
+    HEADING_6: "Heading6",
-    TITLE = "Title",
+    TITLE: "Title",
-}
+} as const;
 
 export class Style extends XmlComponent {
     public constructor(styleId: string) {

src/file/paragraph/formatting/tab-stop.ts

@@ -2,9 +2,9 @@
 import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 
 export interface TabStopDefinition {
-    readonly type: TabStopType;
+    readonly type: (typeof TabStopType)[keyof typeof TabStopType];
-    readonly position: number | TabStopPosition;
+    readonly position: number | (typeof TabStopPosition)[keyof typeof TabStopPosition];
-    readonly leader?: LeaderType;
+    readonly leader?: (typeof LeaderType)[keyof typeof LeaderType];
 }
 
 export class TabStop extends XmlComponent {
@@ -17,34 +17,35 @@ export class TabStop extends XmlComponent {
     }
 }
 
-export enum TabStopType {
+export const TabStopType = {
-    LEFT = "left",
+    LEFT: "left",
-    RIGHT = "right",
+    RIGHT: "right",
-    CENTER = "center",
+    CENTER: "center",
-    BAR = "bar",
+    BAR: "bar",
-    CLEAR = "clear",
+    CLEAR: "clear",
-    DECIMAL = "decimal",
+    DECIMAL: "decimal",
-    END = "end",
+    END: "end",
-    NUM = "num",
+    NUM: "num",
-    START = "start",
+    START: "start",
-}
+} as const;
 
-export enum LeaderType {
+export const LeaderType = {
-    DOT = "dot",
+    DOT: "dot",
-    HYPHEN = "hyphen",
+    HYPHEN: "hyphen",
-    MIDDLE_DOT = "middleDot",
+    // eslint-disable-next-line @typescript-eslint/naming-convention
-    NONE = "none",
+    MIDDLE_DOT: "middleDot",
-    UNDERSCORE = "underscore",
+    NONE: "none",
-}
+    UNDERSCORE: "underscore",
+} as const;
 
-export enum TabStopPosition {
+export const TabStopPosition = {
-    MAX = 9026,
+    MAX: 9026,
-}
+} as const;
 
 export class TabAttributes extends XmlAttributeComponent<{
-    readonly val: TabStopType;
+    readonly val: (typeof TabStopType)[keyof typeof TabStopType];
     readonly pos: string | number;
-    readonly leader?: LeaderType;
+    readonly leader?: (typeof LeaderType)[keyof typeof LeaderType];
 }> {
     protected readonly xmlKeys = { val: "w:val", pos: "w:pos", leader: "w:leader" };
 }

src/file/paragraph/frame/frame-properties.ts

@@ -3,43 +3,44 @@ import { HorizontalPositionAlign, VerticalPositionAlign } from "@file/shared/ali
 import { HeightRule } from "@file/table";
 import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 
-export enum DropCapType {
+export const DropCapType = {
-    NONE = "none",
+    NONE: "none",
-    DROP = "drop",
+    DROP: "drop",
-    MARGIN = "margin",
+    MARGIN: "margin",
-}
+} as const;
 
-export enum FrameAnchorType {
+export const FrameAnchorType = {
-    MARGIN = "margin",
+    MARGIN: "margin",
-    PAGE = "page",
+    PAGE: "page",
-    TEXT = "text",
+    TEXT: "text",
-}
+} as const;
 
-export enum FrameWrap {
+export const FrameWrap = {
-    AROUND = "around",
+    AROUND: "around",
-    AUTO = "auto",
+    AUTO: "auto",
-    NONE = "none",
+    NONE: "none",
-    NOT_BESIDE = "notBeside",
+    // eslint-disable-next-line @typescript-eslint/naming-convention
-    THROUGH = "through",
+    NOT_BESIDE: "notBeside",
-    TIGHT = "tight",
+    THROUGH: "through",
-}
+    TIGHT: "tight",
+} as const;
 
 interface IBaseFrameOptions {
     readonly anchorLock?: boolean;
-    readonly dropCap?: DropCapType;
+    readonly dropCap?: (typeof DropCapType)[keyof typeof DropCapType];
     readonly width: number;
     readonly height: number;
-    readonly wrap?: FrameWrap;
+    readonly wrap?: (typeof FrameWrap)[keyof typeof FrameWrap];
     readonly lines?: number;
     readonly anchor: {
-        readonly horizontal: FrameAnchorType;
+        readonly horizontal: (typeof FrameAnchorType)[keyof typeof FrameAnchorType];
-        readonly vertical: FrameAnchorType;
+        readonly vertical: (typeof FrameAnchorType)[keyof typeof FrameAnchorType];
     };
     readonly space?: {
         readonly horizontal: number;
         readonly vertical: number;
     };
-    readonly rule?: HeightRule;
+    readonly rule?: (typeof HeightRule)[keyof typeof HeightRule];
 }
 
 export interface IXYFrameOptions extends IBaseFrameOptions {
@@ -51,8 +52,8 @@ export interface IXYFrameOptions extends IBaseFrameOptions {
 
 export interface IAlignmentFrameOptions extends IBaseFrameOptions {
     readonly alignment: {
-        readonly x: HorizontalPositionAlign;
+        readonly x: (typeof HorizontalPositionAlign)[keyof typeof HorizontalPositionAlign];
-        readonly y: VerticalPositionAlign;
+        readonly y: (typeof VerticalPositionAlign)[keyof typeof VerticalPositionAlign];
     };
 }
 
@@ -62,20 +63,20 @@ export type IFrameOptions = IXYFrameOptions | IAlignmentFrameOptions;
 
 export class FramePropertiesAttributes extends XmlAttributeComponent<{
     readonly anchorLock?: boolean;
-    readonly dropCap?: DropCapType;
+    readonly dropCap?: (typeof DropCapType)[keyof typeof DropCapType];
     readonly width: number;
     readonly height: number;
     readonly x?: number;
     readonly y?: number;
-    readonly wrap?: FrameWrap;
+    readonly wrap?: (typeof FrameWrap)[keyof typeof FrameWrap];
     readonly lines?: number;
-    readonly anchorHorizontal?: FrameAnchorType;
+    readonly anchorHorizontal?: (typeof FrameAnchorType)[keyof typeof FrameAnchorType];
-    readonly anchorVertical?: FrameAnchorType;
+    readonly anchorVertical?: (typeof FrameAnchorType)[keyof typeof FrameAnchorType];
     readonly spaceHorizontal?: number;
     readonly spaceVertical?: number;
-    readonly rule?: HeightRule;
+    readonly rule?: (typeof HeightRule)[keyof typeof HeightRule];
-    readonly alignmentX?: HorizontalPositionAlign;
+    readonly alignmentX?: (typeof HorizontalPositionAlign)[keyof typeof HorizontalPositionAlign];
-    readonly alignmentY?: VerticalPositionAlign;
+    readonly alignmentY?: (typeof VerticalPositionAlign)[keyof typeof VerticalPositionAlign];
 }> {
     protected readonly xmlKeys = {
         anchorLock: "w:anchorLock",

src/file/paragraph/links/hyperlink.ts

@@ -5,10 +5,10 @@ import { uniqueId } from "@util/convenience-functions";
 import { ParagraphChild } from "../paragraph";
 import { HyperlinkAttributes, IHyperlinkAttributesProperties } from "./hyperlink-attributes";
 
-export enum HyperlinkType {
+export const HyperlinkType = {
-    INTERNAL = "INTERNAL",
+    INTERNAL: "INTERNAL",
-    EXTERNAL = "EXTERNAL",
+    EXTERNAL: "EXTERNAL",
-}
+} as const;
 
 export class ConcreteHyperlink extends XmlComponent {
     public readonly linkId: string;
@@ -39,7 +39,12 @@ export class InternalHyperlink extends ConcreteHyperlink {
 }
 
 export class ExternalHyperlink extends XmlComponent {
-    public constructor(public readonly options: { readonly children: readonly ParagraphChild[]; readonly link: string }) {
+    public constructor(
+        public readonly options: {
+            readonly children: readonly ParagraphChild[];
+            readonly link: string;
+        },
+    ) {
         super("w:externalHyperlink");
     }
 }

src/file/paragraph/properties.ts

@@ -18,7 +18,7 @@ import { OutlineLevel } from "./links";
 import { IRunOptions, RunProperties } from ".";
 
 export interface ILevelParagraphStylePropertiesOptions {
-    readonly alignment?: AlignmentType;
+    readonly alignment?: (typeof AlignmentType)[keyof typeof AlignmentType];
     readonly thematicBreak?: boolean;
     readonly contextualSpacing?: boolean;
     readonly rightTabStop?: number;
@@ -47,7 +47,7 @@ export interface IParagraphStylePropertiesOptions extends ILevelParagraphStylePr
 
 export interface IParagraphPropertiesOptions extends IParagraphStylePropertiesOptions {
     readonly border?: IBordersOptions;
-    readonly heading?: HeadingLevel;
+    readonly heading?: (typeof HeadingLevel)[keyof typeof HeadingLevel];
     readonly bidirectional?: boolean;
     readonly pageBreakBefore?: boolean;
     readonly tabStops?: readonly TabStopDefinition[];

src/file/paragraph/run/emphasis-mark.ts

@@ -1,11 +1,11 @@
 import { Attributes, XmlComponent } from "@file/xml-components";
 
-export enum EmphasisMarkType {
+export const EmphasisMarkType = {
-    DOT = "dot",
+    DOT: "dot",
-}
+} as const;
 
 export abstract class BaseEmphasisMark extends XmlComponent {
-    protected constructor(emphasisMarkType: EmphasisMarkType) {
+    protected constructor(emphasisMarkType: (typeof EmphasisMarkType)[keyof typeof EmphasisMarkType]) {
         super("w:em");
         this.root.push(
             new Attributes({
@@ -16,7 +16,7 @@ export abstract class BaseEmphasisMark extends XmlComponent {
 }
 
 export class EmphasisMark extends BaseEmphasisMark {
-    public constructor(emphasisMarkType: EmphasisMarkType = EmphasisMarkType.DOT) {
+    public constructor(emphasisMarkType: (typeof EmphasisMarkType)[keyof typeof EmphasisMarkType] = EmphasisMarkType.DOT) {
         super(emphasisMarkType);
     }
 }

src/file/paragraph/run/field.ts

@@ -1,12 +1,15 @@
 import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 
-enum FieldCharacterType {
+const FieldCharacterType = {
-    BEGIN = "begin",
+    BEGIN: "begin",
-    END = "end",
+    END: "end",
-    SEPARATE = "separate",
+    SEPARATE: "separate",
-}
+} as const;
 
-class FidCharAttrs extends XmlAttributeComponent<{ readonly type: FieldCharacterType; readonly dirty?: boolean }> {
+class FidCharAttrs extends XmlAttributeComponent<{
+    readonly type: (typeof FieldCharacterType)[keyof typeof FieldCharacterType];
+    readonly dirty?: boolean;
+}> {
     protected readonly xmlKeys = { type: "w:fldCharType", dirty: "w:dirty" };
 }
 

src/file/paragraph/run/positional-tab.ts

@@ -7,11 +7,11 @@ import { NextAttributeComponent, XmlComponent } from "@file/xml-components";
 //         <xsd:enumeration value="right" />
 //     </xsd:restriction>
 // </xsd:simpleType>
-export enum PositionalTabAlignment {
+export const PositionalTabAlignment = {
-    LEFT = "left",
+    LEFT: "left",
-    CENTER = "center",
+    CENTER: "center",
-    RIGHT = "right",
+    RIGHT: "right",
-}
+} as const;
 
 // <xsd:simpleType name="ST_PTabRelativeTo">
 //     <xsd:restriction base="xsd:string">
@@ -19,10 +19,10 @@ export enum PositionalTabAlignment {
 //         <xsd:enumeration value="indent" />
 //     </xsd:restriction>
 // </xsd:simpleType>
-export enum PositionalTabRelativeTo {
+export const PositionalTabRelativeTo = {
-    MARGIN = "margin",
+    MARGIN: "margin",
-    INDENT = "indent",
+    INDENT: "indent",
-}
+} as const;
 
 // <xsd:simpleType name="ST_PTabLeader">
 //     <xsd:restriction base="xsd:string">
@@ -33,18 +33,19 @@ export enum PositionalTabRelativeTo {
 //         <xsd:enumeration value="middleDot" />
 //     </xsd:restriction>
 // </xsd:simpleType>
-export enum PositionalTabLeader {
+export const PositionalTabLeader = {
-    NONE = "none",
+    NONE: "none",
-    DOT = "dot",
+    DOT: "dot",
-    HYPHEN = "hyphen",
+    HYPHEN: "hyphen",
-    UNDERSCORE = "underscore",
+    UNDERSCORE: "underscore",
-    MIDDLE_DOT = "middleDot",
+    // eslint-disable-next-line @typescript-eslint/naming-convention
-}
+    MIDDLE_DOT: "middleDot",
+} as const;
 
 export interface PositionalTabOptions {
-    readonly alignment: PositionalTabAlignment;
+    readonly alignment: (typeof PositionalTabAlignment)[keyof typeof PositionalTabAlignment];
-    readonly relativeTo: PositionalTabRelativeTo;
+    readonly relativeTo: (typeof PositionalTabRelativeTo)[keyof typeof PositionalTabRelativeTo];
-    readonly leader: PositionalTabLeader;
+    readonly leader: (typeof PositionalTabLeader)[keyof typeof PositionalTabLeader];
 }
 
 // <xsd:complexType name="CT_PTab">
@@ -58,9 +59,9 @@ export class PositionalTab extends XmlComponent {
 
         this.root.push(
             new NextAttributeComponent<{
-                readonly alignment: PositionalTabAlignment;
+                readonly alignment: (typeof PositionalTabAlignment)[keyof typeof PositionalTabAlignment];
-                readonly relativeTo: PositionalTabRelativeTo;
+                readonly relativeTo: (typeof PositionalTabRelativeTo)[keyof typeof PositionalTabRelativeTo];
-                readonly leader: PositionalTabLeader;
+                readonly leader: (typeof PositionalTabLeader)[keyof typeof PositionalTabLeader];
             }>({
                 alignment: {
                     key: "w:alignment",

src/file/paragraph/run/properties.ts

@@ -25,15 +25,18 @@ interface IFontOptions {
     readonly hint?: string;
 }
 
-export enum TextEffect {
+/* eslint-disable @typescript-eslint/naming-convention */
-    BLINK_BACKGROUND = "blinkBackground",
+export const TextEffect = {
-    LIGHTS = "lights",
+    BLINK_BACKGROUND: "blinkBackground",
-    ANTS_BLACK = "antsBlack",
+    LIGHTS: "lights",
-    ANTS_RED = "antsRed",
+    ANTS_BLACK: "antsBlack",
-    SHIMMER = "shimmer",
+    ANTS_RED: "antsRed",
-    SPARKLE = "sparkle",
+    SHIMMER: "shimmer",
-    NONE = "none",
+    SPARKLE: "sparkle",
-}
+    NONE: "none",
+} as const;
+
+/* eslint-enable */
 
 export interface IRunStylePropertiesOptions {
     readonly noProof?: boolean;
@@ -43,11 +46,11 @@ export interface IRunStylePropertiesOptions {
     readonly italicsComplexScript?: boolean;
     readonly underline?: {
         readonly color?: string;
-        readonly type?: UnderlineType;
+        readonly type?: (typeof UnderlineType)[keyof typeof UnderlineType];
     };
-    readonly effect?: TextEffect;
+    readonly effect?: (typeof TextEffect)[keyof typeof TextEffect];
     readonly emphasisMark?: {
-        readonly type?: EmphasisMarkType;
+        readonly type?: (typeof EmphasisMarkType)[keyof typeof EmphasisMarkType];
     };
     readonly color?: string;
     readonly kern?: number | PositiveUniversalMeasure;
@@ -127,6 +130,8 @@ export interface IRunPropertiesChangeOptions extends IRunPropertiesOptions, ICha
 //     <xsd:element name="oMath" type="CT_OnOff"/>
 //     </xsd:choice>
 // </xsd:group>
+/* eslint-disable functional/immutable-data */
+
 export class RunProperties extends IgnoreIfEmptyXmlComponent {
     public constructor(options?: IRunPropertiesOptions) {
         super("w:rPr");
@@ -294,6 +299,8 @@ export class RunProperties extends IgnoreIfEmptyXmlComponent {
     }
 }
 
+/* eslint-enable */
+
 export class RunPropertiesChange extends XmlComponent {
     public constructor(options: IRunPropertiesChangeOptions) {
         super("w:rPrChange");

src/file/paragraph/run/run-components/text.ts

@@ -12,7 +12,7 @@ import { TextAttributes } from "../text-attributes";
 // </xsd:complexType>
 
 interface ITextOptions {
-    readonly space?: SpaceType;
+    readonly space?: (typeof SpaceType)[keyof typeof SpaceType];
     readonly text?: string;
 }
 

src/file/paragraph/run/run.ts

@@ -71,7 +71,7 @@ export interface IRunOptions extends IRunPropertiesOptions {
         | FieldInstruction
         | Separate
         | End
-        | PageNumber
+        | (typeof PageNumber)[keyof typeof PageNumber]
         | FootnoteReferenceRun
         | Break
         | AnnotationReference
@@ -98,11 +98,14 @@ export interface IRunOptions extends IRunPropertiesOptions {
     readonly text?: string;
 }
 
-export enum PageNumber {
+/* eslint-disable @typescript-eslint/naming-convention */
-    CURRENT = "CURRENT",
+export const PageNumber = {
-    TOTAL_PAGES = "TOTAL_PAGES",
+    CURRENT: "CURRENT",
-    TOTAL_PAGES_IN_SECTION = "TOTAL_PAGES_IN_SECTION",
+    TOTAL_PAGES: "TOTAL_PAGES",
-}
+    TOTAL_PAGES_IN_SECTION: "TOTAL_PAGES_IN_SECTION",
+} as const;
+
+/* eslint-enable */
 
 export class Run extends XmlComponent {
     protected readonly properties: RunProperties;

src/file/paragraph/run/text-attributes.ts

@@ -1,6 +1,8 @@
 import { SpaceType } from "@file/shared";
 import { XmlAttributeComponent } from "@file/xml-components";
 
-export class TextAttributes extends XmlAttributeComponent<{ readonly space: SpaceType }> {
+export class TextAttributes extends XmlAttributeComponent<{
+    readonly space: (typeof SpaceType)[keyof typeof SpaceType];
+}> {
     protected readonly xmlKeys = { space: "xml:space" };
 }

src/file/paragraph/run/underline.ts

@@ -1,29 +1,29 @@
 import { Attributes, XmlComponent } from "@file/xml-components";
 import { hexColorValue } from "@util/values";
 
-export enum UnderlineType {
+export const UnderlineType = {
-    SINGLE = "single",
+    SINGLE: "single",
-    WORDS = "words",
+    WORDS: "words",
-    DOUBLE = "double",
+    DOUBLE: "double",
-    THICK = "thick",
+    THICK: "thick",
-    DOTTED = "dotted",
+    DOTTED: "dotted",
-    DOTTEDHEAVY = "dottedHeavy",
+    DOTTEDHEAVY: "dottedHeavy",
-    DASH = "dash",
+    DASH: "dash",
-    DASHEDHEAVY = "dashedHeavy",
+    DASHEDHEAVY: "dashedHeavy",
-    DASHLONG = "dashLong",
+    DASHLONG: "dashLong",
-    DASHLONGHEAVY = "dashLongHeavy",
+    DASHLONGHEAVY: "dashLongHeavy",
-    DOTDASH = "dotDash",
+    DOTDASH: "dotDash",
-    DASHDOTHEAVY = "dashDotHeavy",
+    DASHDOTHEAVY: "dashDotHeavy",
-    DOTDOTDASH = "dotDotDash",
+    DOTDOTDASH: "dotDotDash",
-    DASHDOTDOTHEAVY = "dashDotDotHeavy",
+    DASHDOTDOTHEAVY: "dashDotDotHeavy",
-    WAVE = "wave",
+    WAVE: "wave",
-    WAVYHEAVY = "wavyHeavy",
+    WAVYHEAVY: "wavyHeavy",
-    WAVYDOUBLE = "wavyDouble",
+    WAVYDOUBLE: "wavyDouble",
-    NONE = "none",
+    NONE: "none",
-}
+} as const;
 
 export class Underline extends XmlComponent {
-    public constructor(underlineType: UnderlineType = UnderlineType.SINGLE, color?: string) {
+    public constructor(underlineType: (typeof UnderlineType)[keyof typeof UnderlineType] = UnderlineType.SINGLE, color?: string) {
         super("w:u");
         this.root.push(
             new Attributes({

src/file/relationships/relationship/relationship.ts

@@ -19,12 +19,17 @@ export type RelationshipType =
     | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes"
     | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments";
 
-export enum TargetModeType {
+export const TargetModeType = {
-    EXTERNAL = "External",
+    EXTERNAL: "External",
-}
+} as const;
 
 export class Relationship extends XmlComponent {
-    public constructor(id: string, type: RelationshipType, target: string, targetMode?: TargetModeType) {
+    public constructor(
+        id: string,
+        type: RelationshipType,
+        target: string,
+        targetMode?: (typeof TargetModeType)[keyof typeof TargetModeType],
+    ) {
         super("Relationship");
 
         this.root.push(

src/file/relationships/relationships.ts

@@ -12,7 +12,12 @@ export class Relationships extends XmlComponent {
         );
     }
 
-    public createRelationship(id: number | string, type: RelationshipType, target: string, targetMode?: TargetModeType): Relationship {
+    public createRelationship(
+        id: number | string,
+        type: RelationshipType,
+        target: string,
+        targetMode?: (typeof TargetModeType)[keyof typeof TargetModeType],
+    ): Relationship {
         const relationship = new Relationship(`rId${id}`, type, target, targetMode);
         this.root.push(relationship);
 

src/file/shading/shading.ts

@@ -23,7 +23,7 @@ import { hexColorValue } from "@util/values";
 export interface IShadingAttributesProperties {
     readonly fill?: string;
     readonly color?: string;
-    readonly type?: ShadingType;
+    readonly type?: (typeof ShadingType)[keyof typeof ShadingType];
 }
 
 class ShadingAttributes extends XmlAttributeComponent<IShadingAttributesProperties> {
@@ -47,42 +47,44 @@ export class Shading extends XmlComponent {
     }
 }
 
-export enum ShadingType {
+/* eslint-disable @typescript-eslint/naming-convention */
-    CLEAR = "clear",
+export const ShadingType = {
-    DIAGONAL_CROSS = "diagCross",
+    CLEAR: "clear",
-    DIAGONAL_STRIPE = "diagStripe",
+    DIAGONAL_CROSS: "diagCross",
-    HORIZONTAL_CROSS = "horzCross",
+    DIAGONAL_STRIPE: "diagStripe",
-    HORIZONTAL_STRIPE = "horzStripe",
+    HORIZONTAL_CROSS: "horzCross",
-    NIL = "nil",
+    HORIZONTAL_STRIPE: "horzStripe",
-    PERCENT_5 = "pct5",
+    NIL: "nil",
-    PERCENT_10 = "pct10",
+    PERCENT_5: "pct5",
-    PERCENT_12 = "pct12",
+    PERCENT_10: "pct10",
-    PERCENT_15 = "pct15",
+    PERCENT_12: "pct12",
-    PERCENT_20 = "pct20",
+    PERCENT_15: "pct15",
-    PERCENT_25 = "pct25",
+    PERCENT_20: "pct20",
-    PERCENT_30 = "pct30",
+    PERCENT_25: "pct25",
-    PERCENT_35 = "pct35",
+    PERCENT_30: "pct30",
-    PERCENT_37 = "pct37",
+    PERCENT_35: "pct35",
-    PERCENT_40 = "pct40",
+    PERCENT_37: "pct37",
-    PERCENT_45 = "pct45",
+    PERCENT_40: "pct40",
-    PERCENT_50 = "pct50",
+    PERCENT_45: "pct45",
-    PERCENT_55 = "pct55",
+    PERCENT_50: "pct50",
-    PERCENT_60 = "pct60",
+    PERCENT_55: "pct55",
-    PERCENT_62 = "pct62",
+    PERCENT_60: "pct60",
-    PERCENT_65 = "pct65",
+    PERCENT_62: "pct62",
-    PERCENT_70 = "pct70",
+    PERCENT_65: "pct65",
-    PERCENT_75 = "pct75",
+    PERCENT_70: "pct70",
-    PERCENT_80 = "pct80",
+    PERCENT_75: "pct75",
-    PERCENT_85 = "pct85",
+    PERCENT_80: "pct80",
-    PERCENT_87 = "pct87",
+    PERCENT_85: "pct85",
-    PERCENT_90 = "pct90",
+    PERCENT_87: "pct87",
-    PERCENT_95 = "pct95",
+    PERCENT_90: "pct90",
-    REVERSE_DIAGONAL_STRIPE = "reverseDiagStripe",
+    PERCENT_95: "pct95",
-    SOLID = "solid",
+    REVERSE_DIAGONAL_STRIPE: "reverseDiagStripe",
-    THIN_DIAGONAL_CROSS = "thinDiagCross",
+    SOLID: "solid",
-    THIN_DIAGONAL_STRIPE = "thinDiagStripe",
+    THIN_DIAGONAL_CROSS: "thinDiagCross",
-    THIN_HORIZONTAL_CROSS = "thinHorzCross",
+    THIN_DIAGONAL_STRIPE: "thinDiagStripe",
-    THIN_REVERSE_DIAGONAL_STRIPE = "thinReverseDiagStripe",
+    THIN_HORIZONTAL_CROSS: "thinHorzCross",
-    THIN_VERTICAL_STRIPE = "thinVertStripe",
+    THIN_REVERSE_DIAGONAL_STRIPE: "thinReverseDiagStripe",
-    VERTICAL_STRIPE = "vertStripe",
+    THIN_VERTICAL_STRIPE: "thinVertStripe",
-}
+    VERTICAL_STRIPE: "vertStripe",
+} as const;
+/* eslint-enable */

src/file/shared/alignment.ts

@@ -1,15 +1,15 @@
-export enum HorizontalPositionAlign {
+export const HorizontalPositionAlign = {
-    CENTER = "center",
+    CENTER: "center",
-    INSIDE = "inside",
+    INSIDE: "inside",
-    LEFT = "left",
+    LEFT: "left",
-    OUTSIDE = "outside",
+    OUTSIDE: "outside",
-    RIGHT = "right",
+    RIGHT: "right",
-}
+} as const;
 
-export enum VerticalPositionAlign {
+export const VerticalPositionAlign = {
-    BOTTOM = "bottom",
+    BOTTOM: "bottom",
-    CENTER = "center",
+    CENTER: "center",
-    INSIDE = "inside",
+    INSIDE: "inside",
-    OUTSIDE = "outside",
+    OUTSIDE: "outside",
-    TOP = "top",
+    TOP: "top",
-}
+} as const;

src/file/shared/number-format.ts

@@ -66,68 +66,70 @@
 // </xsd:restriction>
 // </xsd:simpleType>
 
-export enum NumberFormat {
+/* eslint-disable @typescript-eslint/naming-convention*/
-    DECIMAL = "decimal",
+export const NumberFormat = {
-    UPPER_ROMAN = "upperRoman",
+    DECIMAL: "decimal",
-    LOWER_ROMAN = "lowerRoman",
+    UPPER_ROMAN: "upperRoman",
-    UPPER_LETTER = "upperLetter",
+    LOWER_ROMAN: "lowerRoman",
-    LOWER_LETTER = "lowerLetter",
+    UPPER_LETTER: "upperLetter",
-    ORDINAL = "ordinal",
+    LOWER_LETTER: "lowerLetter",
-    CARDINAL_TEXT = "cardinalText",
+    ORDINAL: "ordinal",
-    ORDINAL_TEXT = "ordinalText",
+    CARDINAL_TEXT: "cardinalText",
-    HEX = "hex",
+    ORDINAL_TEXT: "ordinalText",
-    CHICAGO = "chicago",
+    HEX: "hex",
-    IDEOGRAPH_DIGITAL = "ideographDigital",
+    CHICAGO: "chicago",
-    JAPANESE_COUNTING = "japaneseCounting",
+    IDEOGRAPH_DIGITAL: "ideographDigital",
-    AIUEO = "aiueo",
+    JAPANESE_COUNTING: "japaneseCounting",
-    IROHA = "iroha",
+    AIUEO: "aiueo",
-    DECIMAL_FULL_WIDTH = "decimalFullWidth",
+    IROHA: "iroha",
-    DECIMAL_HALF_WIDTH = "decimalHalfWidth",
+    DECIMAL_FULL_WIDTH: "decimalFullWidth",
-    JAPANESE_LEGAL = "japaneseLegal",
+    DECIMAL_HALF_WIDTH: "decimalHalfWidth",
-    JAPANESE_DIGITAL_TEN_THOUSAND = "japaneseDigitalTenThousand",
+    JAPANESE_LEGAL: "japaneseLegal",
-    DECIMAL_ENCLOSED_CIRCLE = "decimalEnclosedCircle",
+    JAPANESE_DIGITAL_TEN_THOUSAND: "japaneseDigitalTenThousand",
-    DECIMAL_FULL_WIDTH_2 = "decimalFullWidth2",
+    DECIMAL_ENCLOSED_CIRCLE: "decimalEnclosedCircle",
-    AIUEO_FULL_WIDTH = "aiueoFullWidth",
+    DECIMAL_FULL_WIDTH_2: "decimalFullWidth2",
-    IROHA_FULL_WIDTH = "irohaFullWidth",
+    AIUEO_FULL_WIDTH: "aiueoFullWidth",
-    DECIMAL_ZERO = "decimalZero",
+    IROHA_FULL_WIDTH: "irohaFullWidth",
-    BULLET = "bullet",
+    DECIMAL_ZERO: "decimalZero",
-    GANADA = "ganada",
+    BULLET: "bullet",
-    CHOSUNG = "chosung",
+    GANADA: "ganada",
-    DECIMAL_ENCLOSED_FULL_STOP = "decimalEnclosedFullstop",
+    CHOSUNG: "chosung",
-    DECIMAL_ENCLOSED_PAREN = "decimalEnclosedParen",
+    DECIMAL_ENCLOSED_FULL_STOP: "decimalEnclosedFullstop",
-    DECIMAL_ENCLOSED_CIRCLE_CHINESE = "decimalEnclosedCircleChinese",
+    DECIMAL_ENCLOSED_PAREN: "decimalEnclosedParen",
-    IDEOGRAPH_ENCLOSED_CIRCLE = "ideographEnclosedCircle",
+    DECIMAL_ENCLOSED_CIRCLE_CHINESE: "decimalEnclosedCircleChinese",
-    IDEOGRAPH_TRADITIONAL = "ideographTraditional",
+    IDEOGRAPH_ENCLOSED_CIRCLE: "ideographEnclosedCircle",
-    IDEOGRAPH_ZODIAC = "ideographZodiac",
+    IDEOGRAPH_TRADITIONAL: "ideographTraditional",
-    IDEOGRAPH_ZODIAC_TRADITIONAL = "ideographZodiacTraditional",
+    IDEOGRAPH_ZODIAC: "ideographZodiac",
-    TAIWANESE_COUNTING = "taiwaneseCounting",
+    IDEOGRAPH_ZODIAC_TRADITIONAL: "ideographZodiacTraditional",
-    IDEOGRAPH_LEGAL_TRADITIONAL = "ideographLegalTraditional",
+    TAIWANESE_COUNTING: "taiwaneseCounting",
-    TAIWANESE_COUNTING_THOUSAND = "taiwaneseCountingThousand",
+    IDEOGRAPH_LEGAL_TRADITIONAL: "ideographLegalTraditional",
-    TAIWANESE_DIGITAL = "taiwaneseDigital",
+    TAIWANESE_COUNTING_THOUSAND: "taiwaneseCountingThousand",
-    CHINESE_COUNTING = "chineseCounting",
+    TAIWANESE_DIGITAL: "taiwaneseDigital",
-    CHINESE_LEGAL_SIMPLIFIED = "chineseLegalSimplified",
+    CHINESE_COUNTING: "chineseCounting",
-    CHINESE_COUNTING_TEN_THOUSAND = "chineseCountingThousand",
+    CHINESE_LEGAL_SIMPLIFIED: "chineseLegalSimplified",
-    KOREAN_DIGITAL = "koreanDigital",
+    CHINESE_COUNTING_TEN_THOUSAND: "chineseCountingThousand",
-    KOREAN_COUNTING = "koreanCounting",
+    KOREAN_DIGITAL: "koreanDigital",
-    KOREAN_LEGAL = "koreanLegal",
+    KOREAN_COUNTING: "koreanCounting",
-    KOREAN_DIGITAL_2 = "koreanDigital2",
+    KOREAN_LEGAL: "koreanLegal",
-    VIETNAMESE_COUNTING = "vietnameseCounting",
+    KOREAN_DIGITAL_2: "koreanDigital2",
-    RUSSIAN_LOWER = "russianLower",
+    VIETNAMESE_COUNTING: "vietnameseCounting",
-    RUSSIAN_UPPER = "russianUpper",
+    RUSSIAN_LOWER: "russianLower",
-    NONE = "none",
+    RUSSIAN_UPPER: "russianUpper",
-    NUMBER_IN_DASH = "numberInDash",
+    NONE: "none",
-    HEBREW_1 = "hebrew1",
+    NUMBER_IN_DASH: "numberInDash",
-    HEBREW_2 = "hebrew2",
+    HEBREW_1: "hebrew1",
-    ARABIC_ALPHA = "arabicAlpha",
+    HEBREW_2: "hebrew2",
-    ARABIC_ABJAD = "arabicAbjad",
+    ARABIC_ALPHA: "arabicAlpha",
-    HINDI_VOWELS = "hindiVowels",
+    ARABIC_ABJAD: "arabicAbjad",
-    HINDI_CONSONANTS = "hindiConsonants",
+    HINDI_VOWELS: "hindiVowels",
-    HINDI_NUMBERS = "hindiNumbers",
+    HINDI_CONSONANTS: "hindiConsonants",
-    HINDI_COUNTING = "hindiCounting",
+    HINDI_NUMBERS: "hindiNumbers",
-    THAI_LETTERS = "thaiLetters",
+    HINDI_COUNTING: "hindiCounting",
-    THAI_NUMBERS = "thaiNumbers",
+    THAI_LETTERS: "thaiLetters",
-    THAI_COUNTING = "thaiCounting",
+    THAI_NUMBERS: "thaiNumbers",
-    BAHT_TEXT = "bahtText",
+    THAI_COUNTING: "thaiCounting",
-    DOLLAR_TEXT = "dollarText",
+    BAHT_TEXT: "bahtText",
+    DOLLAR_TEXT: "dollarText",
     //   <xsd:enumeration value="custom"/>
-}
+} as const;
+/* eslint-enable */

src/file/shared/space-type.ts

@@ -1,4 +1,4 @@
-export enum SpaceType {
+export const SpaceType = {
-    DEFAULT = "default",
+    DEFAULT: "default",
-    PRESERVE = "preserve",
+    PRESERVE: "preserve",
-}
+} as const;

src/file/table/table-cell/table-cell-components.ts

@@ -80,18 +80,20 @@ export class GridSpan extends XmlComponent {
 /**
  * Vertical merge types.
  */
-export enum VerticalMergeType {
+export const VerticalMergeType = {
     /**
      * Cell that is merged with upper one.
      */
-    CONTINUE = "continue",
+    CONTINUE: "continue",
     /**
      * Cell that is starting the vertical merge.
      */
-    RESTART = "restart",
+    RESTART: "restart",
-}
+} as const;
 
-class VerticalMergeAttributes extends XmlAttributeComponent<{ readonly val: VerticalMergeType }> {
+class VerticalMergeAttributes extends XmlAttributeComponent<{
+    readonly val: (typeof VerticalMergeType)[keyof typeof VerticalMergeType];
+}> {
     protected readonly xmlKeys = { val: "w:val" };
 }
 
@@ -99,7 +101,7 @@ class VerticalMergeAttributes extends XmlAttributeComponent<{ readonly val: Vert
  * Vertical merge element. Should be used in a table cell.
  */
 export class VerticalMerge extends XmlComponent {
-    public constructor(value: VerticalMergeType) {
+    public constructor(value: (typeof VerticalMergeType)[keyof typeof VerticalMergeType]) {
         super("w:vMerge");
 
         this.root.push(
@@ -110,13 +112,18 @@ export class VerticalMerge extends XmlComponent {
     }
 }
 
-export enum TextDirection {
+export const TextDirection = {
-    BOTTOM_TO_TOP_LEFT_TO_RIGHT = "btLr",
+    // eslint-disable-next-line @typescript-eslint/naming-convention
-    LEFT_TO_RIGHT_TOP_TO_BOTTOM = "lrTb",
+    BOTTOM_TO_TOP_LEFT_TO_RIGHT: "btLr",
-    TOP_TO_BOTTOM_RIGHT_TO_LEFT = "tbRl",
+    // eslint-disable-next-line @typescript-eslint/naming-convention
-}
+    LEFT_TO_RIGHT_TOP_TO_BOTTOM: "lrTb",
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    TOP_TO_BOTTOM_RIGHT_TO_LEFT: "tbRl",
+} as const;
 
-class TDirectionAttributes extends XmlAttributeComponent<{ readonly val: TextDirection }> {
+class TDirectionAttributes extends XmlAttributeComponent<{
+    readonly val: (typeof TextDirection)[keyof typeof TextDirection];
+}> {
     protected readonly xmlKeys = { val: "w:val" };
 }
 
@@ -124,7 +131,7 @@ class TDirectionAttributes extends XmlAttributeComponent<{ readonly val: TextDir
  * Text Direction within a table cell
  */
 export class TDirection extends XmlComponent {
-    public constructor(value: TextDirection) {
+    public constructor(value: (typeof TextDirection)[keyof typeof TextDirection]) {
         super("w:textDirection");
 
         this.root.push(

src/file/table/table-cell/table-cell-properties.ts

@@ -17,9 +17,9 @@ import {
 export interface ITableCellPropertiesOptions {
     readonly shading?: IShadingAttributesProperties;
     readonly margins?: ITableCellMarginOptions;
-    readonly verticalAlign?: VerticalAlign;
+    readonly verticalAlign?: (typeof VerticalAlign)[keyof typeof VerticalAlign];
-    readonly textDirection?: TextDirection;
+    readonly textDirection?: (typeof TextDirection)[keyof typeof TextDirection];
-    readonly verticalMerge?: VerticalMergeType;
+    readonly verticalMerge?: (typeof VerticalMergeType)[keyof typeof VerticalMergeType];
     readonly width?: ITableWidthProperties;
     readonly columnSpan?: number;
     readonly rowSpan?: number;

src/file/table/table-properties/table-cell-margin.ts

@@ -1,8 +1,8 @@
 import { IgnoreIfEmptyXmlComponent } from "@file/xml-components";
-import { TableWidthElement, WidthType } from "../table-width";
+import { TableWidthElement, WidthType } from "@file/table";
 
 export interface ITableCellMarginOptions {
-    readonly marginUnitType?: WidthType;
+    readonly marginUnitType?: (typeof WidthType)[keyof typeof WidthType];
     readonly top?: number;
     readonly bottom?: number;
     readonly left?: number;
@@ -33,14 +33,15 @@ export interface ITableCellMarginOptions {
 //     </xsd:sequence>
 // </xsd:complexType>
 
-export enum TableCellMarginElementType {
+export const TableCellMarginElementType = {
-    TABLE = "w:tblCellMar",
+    TABLE: "w:tblCellMar",
-    TABLE_CELL = "w:tcMar",
+    // eslint-disable-next-line @typescript-eslint/naming-convention
-}
+    TABLE_CELL: "w:tcMar",
+} as const;
 
 export class TableCellMargin extends IgnoreIfEmptyXmlComponent {
     public constructor(
-        type: TableCellMarginElementType,
+        type: (typeof TableCellMarginElementType)[keyof typeof TableCellMarginElementType],
         { marginUnitType = WidthType.DXA, top, left, bottom, right }: ITableCellMarginOptions,
     ) {
         super(type);

src/file/table/table-properties/table-float-properties.ts

@@ -1,28 +1,28 @@
 import { NextAttributeComponent, StringEnumValueElement, XmlComponent } from "@file/xml-components";
 import { PositiveUniversalMeasure, signedTwipsMeasureValue, twipsMeasureValue, UniversalMeasure } from "@util/values";
 
-export enum TableAnchorType {
+export const TableAnchorType = {
-    MARGIN = "margin",
+    MARGIN: "margin",
-    PAGE = "page",
+    PAGE: "page",
-    TEXT = "text",
+    TEXT: "text",
-}
+} as const;
 
-export enum RelativeHorizontalPosition {
+export const RelativeHorizontalPosition = {
-    CENTER = "center",
+    CENTER: "center",
-    INSIDE = "inside",
+    INSIDE: "inside",
-    LEFT = "left",
+    LEFT: "left",
-    OUTSIDE = "outside",
+    OUTSIDE: "outside",
-    RIGHT = "right",
+    RIGHT: "right",
-}
+} as const;
 
-export enum RelativeVerticalPosition {
+export const RelativeVerticalPosition = {
-    CENTER = "center",
+    CENTER: "center",
-    INSIDE = "inside",
+    INSIDE: "inside",
-    BOTTOM = "bottom",
+    BOTTOM: "bottom",
-    OUTSIDE = "outside",
+    OUTSIDE: "outside",
-    INLINE = "inline",
+    INLINE: "inline",
-    TOP = "top",
+    TOP: "top",
-}
+} as const;
 
 // <xsd:simpleType name="ST_TblOverlap">
 //     <xsd:restriction base="xsd:string">
@@ -30,10 +30,10 @@ export enum RelativeVerticalPosition {
 //         <xsd:enumeration value="overlap"/>
 //     </xsd:restriction>
 // </xsd:simpleType>
-export enum OverlapType {
+export const OverlapType = {
-    NEVER = "never",
+    NEVER: "never",
-    OVERLAP = "overlap",
+    OVERLAP: "overlap",
-}
+} as const;
 
 export type ITableFloatOptions = {
     /* cSpell:disable */
@@ -46,7 +46,7 @@ export type ITableFloatOptions = {
      * If omitted, the value is assumed to be page.
      */
     /* cSpell:enable */
-    readonly horizontalAnchor?: TableAnchorType;
+    readonly horizontalAnchor?: (typeof TableAnchorType)[keyof typeof TableAnchorType];
 
     /**
      * Specifies an absolute horizontal position for the table, relative to the horizontalAnchor.
@@ -67,7 +67,7 @@ export type ITableFloatOptions = {
      * outside - the table should be outside of the anchor
      * right - the table should be right aligned with respect to the anchor
      */
-    readonly relativeHorizontalPosition?: RelativeHorizontalPosition;
+    readonly relativeHorizontalPosition?: (typeof RelativeHorizontalPosition)[keyof typeof RelativeHorizontalPosition];
 
     /**
      * Specifies the vertical anchor or the base object from which the vertical positioning
@@ -77,7 +77,7 @@ export type ITableFloatOptions = {
      * text - relative to the horizontal edge of the text margin for the column in which the anchor paragraph is located
      * If omitted, the value is assumed to be page.
      */
-    readonly verticalAnchor?: TableAnchorType;
+    readonly verticalAnchor?: (typeof TableAnchorType)[keyof typeof TableAnchorType];
 
     /**
      * Specifies an absolute vertical position for the table, relative to the verticalAnchor anchor.
@@ -98,7 +98,7 @@ export type ITableFloatOptions = {
      * inline - the table should be vertically aligned in line with the surrounding text (so as to not allow any text wrapping around it)
      * top - the table should be vertically aligned to the top edge of the anchor
      */
-    readonly relativeVerticalPosition?: RelativeVerticalPosition;
+    readonly relativeVerticalPosition?: (typeof RelativeVerticalPosition)[keyof typeof RelativeVerticalPosition];
 
     /**
      * Specifies the minimum distance to be maintained between the table and the top of text in the paragraph
@@ -123,7 +123,7 @@ export type ITableFloatOptions = {
      * to the right of the table. The value is in twentieths of a point. If omitted, the value is assumed to be zero.
      */
     readonly rightFromText?: number | PositiveUniversalMeasure;
-    readonly overlap?: OverlapType;
+    readonly overlap?: (typeof OverlapType)[keyof typeof OverlapType];
 };
 
 // <xsd:complexType name="CT_TblPPr">
@@ -156,12 +156,18 @@ export class TableFloatProperties extends XmlComponent {
         super("w:tblpPr");
         this.root.push(
             new NextAttributeComponent<Omit<ITableFloatOptions, "overlap">>({
-                leftFromText: { key: "w:leftFromText", value: leftFromText === undefined ? undefined : twipsMeasureValue(leftFromText) },
+                leftFromText: {
+                    key: "w:leftFromText",
+                    value: leftFromText === undefined ? undefined : twipsMeasureValue(leftFromText),
+                },
                 rightFromText: {
                     key: "w:rightFromText",
                     value: rightFromText === undefined ? undefined : twipsMeasureValue(rightFromText),
                 },
-                topFromText: { key: "w:topFromText", value: topFromText === undefined ? undefined : twipsMeasureValue(topFromText) },
+                topFromText: {
+                    key: "w:topFromText",
+                    value: topFromText === undefined ? undefined : twipsMeasureValue(topFromText),
+                },
                 bottomFromText: {
                     key: "w:bottomFromText",
                     value: bottomFromText === undefined ? undefined : twipsMeasureValue(bottomFromText),
@@ -197,7 +203,7 @@ export class TableFloatProperties extends XmlComponent {
             // <xsd:complexType name="CT_TblOverlap">
             //     <xsd:attribute name="val" type="ST_TblOverlap" use="required"/>
             // </xsd:complexType>
-            this.root.push(new StringEnumValueElement<OverlapType>("w:tblOverlap", overlap));
+            this.root.push(new StringEnumValueElement<(typeof OverlapType)[keyof typeof OverlapType]>("w:tblOverlap", overlap));
         }
     }
 }

src/file/table/table-properties/table-layout.ts

@@ -6,12 +6,14 @@ import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 //         <xsd:enumeration value="autofit"/>
 //     </xsd:restriction>
 // </xsd:simpleType>
-export enum TableLayoutType {
+export const TableLayoutType = {
-    AUTOFIT = "autofit",
+    AUTOFIT: "autofit",
-    FIXED = "fixed",
+    FIXED: "fixed",
-}
+} as const;
 
-class TableLayoutAttributes extends XmlAttributeComponent<{ readonly type: TableLayoutType }> {
+class TableLayoutAttributes extends XmlAttributeComponent<{
+    readonly type: (typeof TableLayoutType)[keyof typeof TableLayoutType];
+}> {
     protected readonly xmlKeys = { type: "w:type" };
 }
 
@@ -19,7 +21,7 @@ class TableLayoutAttributes extends XmlAttributeComponent<{ readonly type: Table
 //     <xsd:attribute name="type" type="ST_TblLayoutType"/>
 // </xsd:complexType>
 export class TableLayout extends XmlComponent {
-    public constructor(type: TableLayoutType) {
+    public constructor(type: (typeof TableLayoutType)[keyof typeof TableLayoutType]) {
         super("w:tblLayout");
         this.root.push(new TableLayoutAttributes({ type }));
     }

src/file/table/table-properties/table-properties.ts

@@ -34,12 +34,12 @@ import { TableLayout, TableLayoutType } from "./table-layout";
 export interface ITablePropertiesOptions {
     readonly width?: ITableWidthProperties;
     readonly indent?: ITableWidthProperties;
-    readonly layout?: TableLayoutType;
+    readonly layout?: (typeof TableLayoutType)[keyof typeof TableLayoutType];
     readonly borders?: ITableBordersOptions;
     readonly float?: ITableFloatOptions;
     readonly shading?: IShadingAttributesProperties;
     readonly style?: string;
-    readonly alignment?: AlignmentType;
+    readonly alignment?: (typeof AlignmentType)[keyof typeof AlignmentType];
     readonly cellMargin?: ITableCellMarginOptions;
     readonly visuallyRightToLeft?: boolean;
 }

src/file/table/table-row/table-row-height.ts

@@ -13,24 +13,24 @@ import { PositiveUniversalMeasure, twipsMeasureValue } from "@util/values";
 //         <xsd:enumeration value="atLeast"/>
 //     </xsd:restriction>
 // </xsd:simpleType>
-export enum HeightRule {
+export const HeightRule = {
     /** Height is determined based on the content, so value is ignored. */
-    AUTO = "auto",
+    AUTO: "auto",
     /** At least the value specified */
-    ATLEAST = "atLeast",
+    ATLEAST: "atLeast",
     /** Exactly the value specified */
-    EXACT = "exact",
+    EXACT: "exact",
-}
+} as const;
 
 export class TableRowHeightAttributes extends XmlAttributeComponent<{
     readonly value: number | string;
-    readonly rule: HeightRule;
+    readonly rule: (typeof HeightRule)[keyof typeof HeightRule];
 }> {
     protected readonly xmlKeys = { value: "w:val", rule: "w:hRule" };
 }
 
 export class TableRowHeight extends XmlComponent {
-    public constructor(value: number | PositiveUniversalMeasure, rule: HeightRule) {
+    public constructor(value: number | PositiveUniversalMeasure, rule: (typeof HeightRule)[keyof typeof HeightRule]) {
         super("w:trHeight");
 
         this.root.push(

src/file/table/table-row/table-row-properties.ts

@@ -37,7 +37,7 @@ export interface ITableRowPropertiesOptions {
     readonly tableHeader?: boolean;
     readonly height?: {
         readonly value: number | PositiveUniversalMeasure;
-        readonly rule: HeightRule;
+        readonly rule: (typeof HeightRule)[keyof typeof HeightRule];
     };
 }
 

src/file/table/table-width.ts

@@ -10,16 +10,17 @@ import { measurementOrPercentValue, Percentage, UniversalMeasure } from "@util/v
 //     <xsd:enumeration value="auto"/>
 //   </xsd:restriction>
 // </xsd:simpleType>
-export enum WidthType {
+
+export const WidthType = {
     /** Auto. */
-    AUTO = "auto",
+    AUTO: "auto",
     /** Value is in twentieths of a point */
-    DXA = "dxa",
+    DXA: "dxa",
     /** No (empty) value. */
-    NIL = "nil",
+    NIL: "nil",
     /** Value is in percentage. */
-    PERCENTAGE = "pct",
+    PERCENTAGE: "pct",
-}
+} as const;
 
 // <xsd:complexType name="CT_TblWidth">
 //     <xsd:attribute name="w" type="ST_MeasurementOrPercent"/>
@@ -27,7 +28,7 @@ export enum WidthType {
 // </xsd:complexType>
 export type ITableWidthProperties = {
     readonly size: number | Percentage | UniversalMeasure;
-    readonly type?: WidthType;
+    readonly type?: (typeof WidthType)[keyof typeof WidthType];
 };
 
 export class TableWidthElement extends XmlComponent {

src/file/table/table.ts

@@ -27,10 +27,10 @@ export interface ITableOptions {
     readonly margins?: ITableCellMarginOptions;
     readonly indent?: ITableWidthProperties;
     readonly float?: ITableFloatOptions;
-    readonly layout?: TableLayoutType;
+    readonly layout?: (typeof TableLayoutType)[keyof typeof TableLayoutType];
     readonly style?: string;
     readonly borders?: ITableBordersOptions;
-    readonly alignment?: AlignmentType;
+    readonly alignment?: (typeof AlignmentType)[keyof typeof AlignmentType];
     readonly visuallyRightToLeft?: boolean;
 }
 

src/file/vertical-align/vertical-align.ts

@@ -11,13 +11,14 @@ import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 //   <xsd:enumeration value="bottom"/>
 // </xsd:restriction>
 // </xsd:simpleType>
-export enum VerticalAlign {
+export const VerticalAlign = {
-    BOTTOM = "bottom",
+    BOTTOM: "bottom",
-    CENTER = "center",
+    CENTER: "center",
-    TOP = "top",
+    TOP: "top",
-}
+} as const;
+
 export class VerticalAlignAttributes extends XmlAttributeComponent<{
-    readonly verticalAlign?: VerticalAlign;
+    readonly verticalAlign?: (typeof VerticalAlign)[keyof typeof VerticalAlign];
 }> {
     protected readonly xmlKeys = {
         verticalAlign: "w:val",
@@ -25,7 +26,7 @@ export class VerticalAlignAttributes extends XmlAttributeComponent<{
 }
 
 export class VerticalAlignElement extends XmlComponent {
-    public constructor(value: VerticalAlign) {
+    public constructor(value: (typeof VerticalAlign)[keyof typeof VerticalAlign]) {
         super("w:vAlign");
         this.root.push(new VerticalAlignAttributes({ verticalAlign: value }));
     }

src/patcher/from-docx.ts

@@ -20,18 +20,18 @@ import { appendContentType } from "./content-types-manager";
 // eslint-disable-next-line functional/prefer-readonly-type
 type InputDataType = Buffer | string | number[] | Uint8Array | ArrayBuffer | Blob | NodeJS.ReadableStream;
 
-export enum PatchType {
+export const PatchType = {
-    DOCUMENT = "file",
+    DOCUMENT: "file",
-    PARAGRAPH = "paragraph",
+    PARAGRAPH: "paragraph",
-}
+} as const;
 
 type ParagraphPatch = {
-    readonly type: PatchType.PARAGRAPH;
+    readonly type: typeof PatchType.PARAGRAPH;
     readonly children: readonly ParagraphChild[];
 };
 
 type FilePatch = {
-    readonly type: PatchType.DOCUMENT;
+    readonly type: typeof PatchType.DOCUMENT;
     readonly children: readonly FileChild[];
 };
 
@@ -83,7 +83,12 @@ export const patchDocument = async (data: InputDataType, options: PatchDocumentO
                 file,
                 viewWrapper: {
                     Relationships: {
-                        createRelationship: (linkId: string, _: string, target: string, __: TargetModeType) => {
+                        createRelationship: (
+                            linkId: string,
+                            _: string,
+                            target: string,
+                            __: (typeof TargetModeType)[keyof typeof TargetModeType],
+                        ) => {
                             // eslint-disable-next-line functional/immutable-data
                             hyperlinkRelationshipAdditions.push({
                                 key,

src/patcher/paragraph-token-replacer.ts

@@ -3,11 +3,11 @@ import { Element } from "xml-js";
 import { createTextElementContents, patchSpaceAttribute } from "./util";
 import { IRenderedParagraphNode } from "./run-renderer";
 
-enum ReplaceMode {
+const ReplaceMode = {
-    START,
+    START: 0,
-    MIDDLE,
+    MIDDLE: 1,
-    END,
+    END: 2,
-}
+} as const;
 
 export const replaceTokenInParagraphElement = ({
     paragraphElement,
@@ -23,7 +23,7 @@ export const replaceTokenInParagraphElement = ({
     const startIndex = renderedParagraph.text.indexOf(originalText);
     const endIndex = startIndex + originalText.length - 1;
 
-    let replaceMode = ReplaceMode.START;
+    let replaceMode: (typeof ReplaceMode)[keyof typeof ReplaceMode] = ReplaceMode.START;
 
     for (const run of renderedParagraph.runs) {
         for (const { text, index, start, end } of run.parts) {

src/patcher/relationship-manager.ts

@@ -23,7 +23,7 @@ export const appendRelationship = (
     id: number | string,
     type: RelationshipType,
     target: string,
-    targetMode?: TargetModeType,
+    targetMode?: (typeof TargetModeType)[keyof typeof TargetModeType],
 ): readonly Element[] => {
     const relationshipElements = getFirstLevelElements(relationships, "Relationships");
     // eslint-disable-next-line functional/immutable-data