docx 9.6.0 → 9.7.0

package/dist/file/footer/footer.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/footer/index.d.ts

@@ -0,0 +1 @@
+export * from './footer';

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

@@ -0,0 +1,23 @@
+import { XmlComponent } from './xml-components';
+import { HeaderFooterReferenceType } from './document';
+import { IViewWrapper } from './document-wrapper';
+import { Footer } from './footer/footer';
+import { Media } from './media';
+import { Paragraph } from './paragraph';
+import { Relationships } from './relationships';
+import { Table } from './table';
+export type IDocumentFooter = {
+    readonly footer: FooterWrapper;
+    readonly type: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType];
+};
+export declare class FooterWrapper implements IViewWrapper {
+    private readonly media;
+    private readonly footer;
+    private readonly relationships;
+    constructor(media: Media, referenceId: number, initContent?: XmlComponent);
+    add(item: Paragraph | Table): void;
+    addChildElement(childElement: XmlComponent): void;
+    get View(): Footer;
+    get Relationships(): Relationships;
+    get Media(): Media;
+}

package/dist/file/footer-wrapper.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/footnotes/footnote/footnote-attributes.d.ts

@@ -0,0 +1,10 @@
+import { XmlAttributeComponent } from '../../xml-components';
+export declare class FootnoteAttributes extends XmlAttributeComponent<{
+    readonly type?: string;
+    readonly id: number;
+}> {
+    protected readonly xmlKeys: {
+        type: string;
+        id: string;
+    };
+}

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

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

package/dist/file/footnotes/footnote/footnote.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/footnotes/footnote/index.d.ts

@@ -0,0 +1 @@
+export * from './run';

package/dist/file/footnotes/footnote/run/continuation-seperator-run.d.ts

@@ -0,0 +1,4 @@
+import { Run } from '../../../paragraph';
+export declare class ContinuationSeperatorRun extends Run {
+    constructor();
+}

package/dist/file/footnotes/footnote/run/continuation-seperator.d.ts

@@ -0,0 +1,4 @@
+import { XmlComponent } from '../../../xml-components';
+export declare class ContinuationSeperator extends XmlComponent {
+    constructor();
+}

package/dist/file/footnotes/footnote/run/footnote-ref-run.d.ts

@@ -0,0 +1,4 @@
+import { Run } from '../../../paragraph';
+export declare class FootnoteRefRun extends Run {
+    constructor();
+}

package/dist/file/footnotes/footnote/run/footnote-ref.d.ts

@@ -0,0 +1,4 @@
+import { XmlComponent } from '../../../xml-components';
+export declare class FootnoteRef extends XmlComponent {
+    constructor();
+}

package/dist/file/footnotes/footnote/run/index.d.ts

@@ -0,0 +1 @@
+export * from './reference-run';

package/dist/file/footnotes/footnote/run/reference-run.d.ts

@@ -0,0 +1,15 @@
+import { Run } from '../../../paragraph/run';
+import { XmlAttributeComponent, XmlComponent } from '../../../xml-components';
+export declare class FootNoteReferenceRunAttributes extends XmlAttributeComponent<{
+    readonly id: number;
+}> {
+    protected readonly xmlKeys: {
+        id: string;
+    };
+}
+export declare class FootnoteReference extends XmlComponent {
+    constructor(id: number);
+}
+export declare class FootnoteReferenceRun extends Run {
+    constructor(id: number);
+}

package/dist/file/footnotes/footnote/run/seperator-run.d.ts

@@ -0,0 +1,4 @@
+import { Run } from '../../../paragraph';
+export declare class SeperatorRun extends Run {
+    constructor();
+}

package/dist/file/footnotes/footnote/run/seperator.d.ts

@@ -0,0 +1,4 @@
+import { XmlComponent } from '../../../xml-components';
+export declare class Seperator extends XmlComponent {
+    constructor();
+}

package/dist/file/footnotes/footnotes-attributes.d.ts

@@ -0,0 +1,40 @@
+import { XmlAttributeComponent } from '../xml-components';
+export declare class FootnotesAttributes extends XmlAttributeComponent<{
+    readonly wpc?: string;
+    readonly mc?: string;
+    readonly o?: string;
+    readonly r?: string;
+    readonly m?: string;
+    readonly v?: string;
+    readonly wp14?: string;
+    readonly wp?: string;
+    readonly w10?: string;
+    readonly w?: string;
+    readonly w14?: string;
+    readonly w15?: string;
+    readonly wpg?: string;
+    readonly wpi?: string;
+    readonly wne?: string;
+    readonly wps?: string;
+    readonly Ignorable?: string;
+}> {
+    protected readonly xmlKeys: {
+        wpc: string;
+        mc: string;
+        o: string;
+        r: string;
+        m: string;
+        v: string;
+        wp14: string;
+        wp: string;
+        w10: string;
+        w: string;
+        w14: string;
+        w15: string;
+        wpg: string;
+        wpi: string;
+        wne: string;
+        wps: string;
+        Ignorable: string;
+    };
+}

package/dist/file/footnotes/footnotes.d.ts

@@ -0,0 +1,6 @@
+import { XmlComponent } from '../xml-components';
+import { Paragraph } from '../paragraph';
+export declare class FootNotes extends XmlComponent {
+    constructor();
+    createFootNote(id: number, paragraph: readonly Paragraph[]): void;
+}

package/dist/file/footnotes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './footnotes';
+export * from './footnote';

package/dist/file/footnotes-wrapper.d.ts

@@ -0,0 +1,10 @@
+import { IViewWrapper } from './document-wrapper';
+import { FootNotes } from './footnotes/footnotes';
+import { Relationships } from './relationships';
+export declare class FootnotesWrapper implements IViewWrapper {
+    private readonly footnotess;
+    private readonly relationships;
+    constructor();
+    get View(): FootNotes;
+    get Relationships(): Relationships;
+}

package/dist/file/footnotes-wrapper.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/header/header-attributes.d.ts

@@ -0,0 +1,73 @@
+import { XmlAttributeComponent } from '../xml-components';
+export type IHeaderAttributesProperties = {
+    readonly wpc?: string;
+    readonly mc?: string;
+    readonly o?: string;
+    readonly r?: string;
+    readonly m?: string;
+    readonly v?: string;
+    readonly wp14?: string;
+    readonly wp?: string;
+    readonly w10?: string;
+    readonly w?: string;
+    readonly w14?: string;
+    readonly w15?: string;
+    readonly wpg?: string;
+    readonly wpi?: string;
+    readonly wne?: string;
+    readonly wps?: string;
+    readonly cp?: string;
+    readonly dc?: string;
+    readonly dcterms?: string;
+    readonly dcmitype?: string;
+    readonly xsi?: string;
+    readonly type?: string;
+    readonly cx?: string;
+    readonly cx1?: string;
+    readonly cx2?: string;
+    readonly cx3?: string;
+    readonly cx4?: string;
+    readonly cx5?: string;
+    readonly cx6?: string;
+    readonly cx7?: string;
+    readonly cx8?: string;
+    readonly w16cid: string;
+    readonly w16se: string;
+};
+export declare class HeaderAttributes extends XmlAttributeComponent<IHeaderAttributesProperties> {
+    protected readonly xmlKeys: {
+        wpc: string;
+        mc: string;
+        o: string;
+        r: string;
+        m: string;
+        v: string;
+        wp14: string;
+        wp: string;
+        w10: string;
+        w: string;
+        w14: string;
+        w15: string;
+        wpg: string;
+        wpi: string;
+        wne: string;
+        wps: string;
+        cp: string;
+        dc: string;
+        dcterms: string;
+        dcmitype: string;
+        xsi: string;
+        type: string;
+        cx: string;
+        cx1: string;
+        cx2: string;
+        cx3: string;
+        cx4: string;
+        cx5: string;
+        cx6: string;
+        cx7: string;
+        cx8: string;
+        w16cid: string;
+        w16se: string;
+    };
+}

package/dist/file/header/header.d.ts

@@ -0,0 +1,9 @@
+import { InitializableXmlComponent, XmlComponent } from '../xml-components';
+import { Paragraph } from '../paragraph';
+import { Table } from '../table';
+export declare class Header extends InitializableXmlComponent {
+    private readonly refId;
+    constructor(referenceNumber: number, initContent?: XmlComponent);
+    get ReferenceId(): number;
+    add(item: Paragraph | Table): void;
+}

package/dist/file/header/header.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/header/index.d.ts

@@ -0,0 +1 @@
+export * from './header';

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

@@ -0,0 +1,23 @@
+import { XmlComponent } from './xml-components';
+import { HeaderFooterReferenceType } from './document';
+import { IViewWrapper } from './document-wrapper';
+import { Header } from './header/header';
+import { Media } from './media';
+import { Paragraph } from './paragraph';
+import { Relationships } from './relationships';
+import { Table } from './table';
+export type IDocumentHeader = {
+    readonly header: HeaderWrapper;
+    readonly type: (typeof HeaderFooterReferenceType)[keyof typeof HeaderFooterReferenceType];
+};
+export declare class HeaderWrapper implements IViewWrapper {
+    private readonly media;
+    private readonly header;
+    private readonly relationships;
+    constructor(media: Media, referenceId: number, initContent?: XmlComponent);
+    add(item: Paragraph | Table): HeaderWrapper;
+    addChildElement(childElement: XmlComponent | string): void;
+    get View(): Header;
+    get Relationships(): Relationships;
+    get Media(): Media;
+}

package/dist/file/header-wrapper.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/header.d.ts

@@ -0,0 +1,13 @@
+import { Paragraph } from './paragraph';
+import { Table } from './table';
+export type IHeaderOptions = {
+    readonly children: readonly (Paragraph | Table)[];
+};
+export declare class Header {
+    readonly options: IHeaderOptions;
+    constructor(options?: IHeaderOptions);
+}
+export declare class Footer {
+    readonly options: IHeaderOptions;
+    constructor(options?: IHeaderOptions);
+}

package/dist/file/index.d.ts

@@ -0,0 +1,25 @@
+export * from './paragraph';
+export * from './table';
+export * from './file';
+export * from './file-child';
+export * from './numbering';
+export * from './media';
+export * from './drawing';
+export * from './document';
+export * from './shading';
+export * from './styles';
+export * from './table-of-contents';
+export * from './xml-components';
+export * from './header-wrapper';
+export * from './footer-wrapper';
+export * from './header';
+export * from './footnotes';
+export * from './endnotes';
+export * from './track-revision';
+export * from './shared';
+export * from './border';
+export * from './vertical-align';
+export * from './checkbox';
+export * from './fonts';
+export * from './textbox';
+export { type IPropertiesOptions } from './core-properties';

package/dist/file/media/data.d.ts

@@ -0,0 +1,59 @@
+import { OutlineOptions } from '../drawing/inline/graphic/graphic-data/pic/shape-properties/outline/outline';
+import { SolidFillOptions } from '../drawing/inline/graphic/graphic-data/pic/shape-properties/outline/solid-fill';
+import { WpsShapeCoreOptions } from '../drawing/inline/graphic/graphic-data/wps';
+export type IMediaDataTransformation = {
+    readonly offset?: {
+        readonly pixels: {
+            readonly x: number;
+            readonly y: number;
+        };
+        readonly emus?: {
+            readonly x: number;
+            readonly y: number;
+        };
+    };
+    readonly pixels: {
+        readonly x: number;
+        readonly y: number;
+    };
+    readonly emus: {
+        readonly x: number;
+        readonly y: number;
+    };
+    readonly flip?: {
+        readonly vertical?: boolean;
+        readonly horizontal?: boolean;
+    };
+    readonly rotation?: number;
+};
+type CoreMediaData = {
+    readonly fileName: string;
+    readonly transformation: IMediaDataTransformation;
+    readonly data: Buffer | Uint8Array | ArrayBuffer;
+};
+type RegularMediaData = {
+    readonly type: "jpg" | "png" | "gif" | "bmp";
+};
+type SvgMediaData = {
+    readonly type: "svg";
+    readonly fallback: RegularMediaData & CoreMediaData;
+};
+export type WpsMediaData = {
+    readonly type: "wps";
+    readonly transformation: IMediaDataTransformation;
+    readonly data: WpsShapeCoreOptions;
+};
+export type WpgCommonMediaData = {
+    readonly outline?: OutlineOptions;
+    readonly solidFill?: SolidFillOptions;
+};
+export type IGroupChildMediaData = (WpsMediaData | IMediaData) & WpgCommonMediaData;
+export type WpgMediaData = {
+    readonly type: "wpg";
+    readonly transformation: IMediaDataTransformation;
+    readonly children: readonly IGroupChildMediaData[];
+};
+export type IExtendedMediaData = IMediaData | WpsMediaData | WpgMediaData;
+export type IMediaData = (RegularMediaData | SvgMediaData) & CoreMediaData;
+export declare const WORKAROUND2 = "";
+export {};

package/dist/file/media/index.d.ts

@@ -0,0 +1,2 @@
+export * from './media';
+export * from './data';

package/dist/file/media/media.d.ts

@@ -0,0 +1,20 @@
+import { IMediaData } from './data';
+export type IMediaTransformation = {
+    readonly offset?: {
+        readonly top?: number;
+        readonly left?: number;
+    };
+    readonly width: number;
+    readonly height: number;
+    readonly flip?: {
+        readonly vertical?: boolean;
+        readonly horizontal?: boolean;
+    };
+    readonly rotation?: number;
+};
+export declare class Media {
+    private readonly map;
+    constructor();
+    addImage(key: string, mediaData: IMediaData): void;
+    get Array(): readonly IMediaData[];
+}

package/dist/file/media/media.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/numbering/abstract-numbering.d.ts

@@ -0,0 +1,6 @@
+import { XmlComponent } from '../xml-components';
+import { ILevelsOptions } from './level';
+export declare class AbstractNumbering extends XmlComponent {
+    readonly id: number;
+    constructor(id: number, levelOptions: readonly ILevelsOptions[]);
+}

package/dist/file/numbering/abstract-numbering.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/numbering/concrete-numbering.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/numbering/index.d.ts

@@ -0,0 +1,4 @@
+export * from './numbering';
+export * from './abstract-numbering';
+export * from './level';
+export * from './num';

package/dist/file/numbering/level.d.ts

@@ -0,0 +1,97 @@
+import { XmlComponent } from '../xml-components';
+import { AlignmentType } from '../paragraph/formatting';
+import { ILevelParagraphStylePropertiesOptions } from '../paragraph/properties';
+import { IRunStylePropertiesOptions } from '../paragraph/run/properties';
+export declare const LevelFormat: {
+    readonly DECIMAL: "decimal";
+    readonly UPPER_ROMAN: "upperRoman";
+    readonly LOWER_ROMAN: "lowerRoman";
+    readonly UPPER_LETTER: "upperLetter";
+    readonly LOWER_LETTER: "lowerLetter";
+    readonly ORDINAL: "ordinal";
+    readonly CARDINAL_TEXT: "cardinalText";
+    readonly ORDINAL_TEXT: "ordinalText";
+    readonly HEX: "hex";
+    readonly CHICAGO: "chicago";
+    readonly IDEOGRAPH__DIGITAL: "ideographDigital";
+    readonly JAPANESE_COUNTING: "japaneseCounting";
+    readonly AIUEO: "aiueo";
+    readonly IROHA: "iroha";
+    readonly DECIMAL_FULL_WIDTH: "decimalFullWidth";
+    readonly DECIMAL_HALF_WIDTH: "decimalHalfWidth";
+    readonly JAPANESE_LEGAL: "japaneseLegal";
+    readonly JAPANESE_DIGITAL_TEN_THOUSAND: "japaneseDigitalTenThousand";
+    readonly DECIMAL_ENCLOSED_CIRCLE: "decimalEnclosedCircle";
+    readonly DECIMAL_FULL_WIDTH2: "decimalFullWidth2";
+    readonly AIUEO_FULL_WIDTH: "aiueoFullWidth";
+    readonly IROHA_FULL_WIDTH: "irohaFullWidth";
+    readonly DECIMAL_ZERO: "decimalZero";
+    readonly BULLET: "bullet";
+    readonly GANADA: "ganada";
+    readonly CHOSUNG: "chosung";
+    readonly DECIMAL_ENCLOSED_FULLSTOP: "decimalEnclosedFullstop";
+    readonly DECIMAL_ENCLOSED_PARENTHESES: "decimalEnclosedParen";
+    readonly DECIMAL_ENCLOSED_CIRCLE_CHINESE: "decimalEnclosedCircleChinese";
+    readonly IDEOGRAPH_ENCLOSED_CIRCLE: "ideographEnclosedCircle";
+    readonly IDEOGRAPH_TRADITIONAL: "ideographTraditional";
+    readonly IDEOGRAPH_ZODIAC: "ideographZodiac";
+    readonly IDEOGRAPH_ZODIAC_TRADITIONAL: "ideographZodiacTraditional";
+    readonly TAIWANESE_COUNTING: "taiwaneseCounting";
+    readonly IDEOGRAPH_LEGAL_TRADITIONAL: "ideographLegalTraditional";
+    readonly TAIWANESE_COUNTING_THOUSAND: "taiwaneseCountingThousand";
+    readonly TAIWANESE_DIGITAL: "taiwaneseDigital";
+    readonly CHINESE_COUNTING: "chineseCounting";
+    readonly CHINESE_LEGAL_SIMPLIFIED: "chineseLegalSimplified";
+    readonly CHINESE_COUNTING_THOUSAND: "chineseCountingThousand";
+    readonly KOREAN_DIGITAL: "koreanDigital";
+    readonly KOREAN_COUNTING: "koreanCounting";
+    readonly KOREAN_LEGAL: "koreanLegal";
+    readonly KOREAN_DIGITAL2: "koreanDigital2";
+    readonly VIETNAMESE_COUNTING: "vietnameseCounting";
+    readonly RUSSIAN_LOWER: "russianLower";
+    readonly RUSSIAN_UPPER: "russianUpper";
+    readonly NONE: "none";
+    readonly NUMBER_IN_DASH: "numberInDash";
+    readonly HEBREW1: "hebrew1";
+    readonly HEBREW2: "hebrew2";
+    readonly ARABIC_ALPHA: "arabicAlpha";
+    readonly ARABIC_ABJAD: "arabicAbjad";
+    readonly HINDI_VOWELS: "hindiVowels";
+    readonly HINDI_CONSONANTS: "hindiConsonants";
+    readonly HINDI_NUMBERS: "hindiNumbers";
+    readonly HINDI_COUNTING: "hindiCounting";
+    readonly THAI_LETTERS: "thaiLetters";
+    readonly THAI_NUMBERS: "thaiNumbers";
+    readonly THAI_COUNTING: "thaiCounting";
+    readonly BAHT_TEXT: "bahtText";
+    readonly DOLLAR_TEXT: "dollarText";
+    readonly CUSTOM: "custom";
+};
+export declare const LevelSuffix: {
+    readonly NOTHING: "nothing";
+    readonly SPACE: "space";
+    readonly TAB: "tab";
+};
+export type ILevelsOptions = {
+    readonly level: number;
+    readonly format?: (typeof LevelFormat)[keyof typeof LevelFormat];
+    readonly text?: string;
+    readonly alignment?: (typeof AlignmentType)[keyof typeof AlignmentType];
+    readonly start?: number;
+    readonly suffix?: (typeof LevelSuffix)[keyof typeof LevelSuffix];
+    readonly isLegalNumberingStyle?: boolean;
+    readonly style?: {
+        readonly run?: IRunStylePropertiesOptions;
+        readonly paragraph?: ILevelParagraphStylePropertiesOptions;
+        readonly style?: string;
+    };
+};
+export declare class LevelBase extends XmlComponent {
+    private readonly paragraphProperties;
+    private readonly runProperties;
+    constructor({ level, format, text, alignment, start, style, suffix, isLegalNumberingStyle, }: ILevelsOptions);
+}
+export declare class Level extends LevelBase {
+}
+export declare class LevelForOverride extends LevelBase {
+}

package/dist/file/numbering/level.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/numbering/multi-level-type.d.ts

@@ -0,0 +1,4 @@
+import { XmlComponent } from '../xml-components';
+export declare class MultiLevelType extends XmlComponent {
+    constructor(value: string);
+}

package/dist/file/numbering/num.d.ts

@@ -0,0 +1,22 @@
+import { XmlComponent } from '../xml-components';
+type IOverrideLevel = {
+    readonly num: number;
+    readonly start?: number;
+};
+export type IConcreteNumberingOptions = {
+    readonly numId: number;
+    readonly abstractNumId: number;
+    readonly reference: string;
+    readonly instance: number;
+    readonly overrideLevels?: readonly IOverrideLevel[];
+};
+export declare class ConcreteNumbering extends XmlComponent {
+    readonly numId: number;
+    readonly reference: string;
+    readonly instance: number;
+    constructor(options: IConcreteNumberingOptions);
+}
+export declare class LevelOverride extends XmlComponent {
+    constructor(levelNum: number, start?: number);
+}
+export {};

package/dist/file/numbering/numbering.d.ts

@@ -0,0 +1,21 @@
+import { IContext, IXmlableObject, XmlComponent } from '../xml-components';
+import { ILevelsOptions } from './level';
+import { ConcreteNumbering } from './num';
+export type INumberingOptions = {
+    readonly config: readonly {
+        readonly levels: readonly ILevelsOptions[];
+        readonly reference: string;
+    }[];
+};
+export declare class Numbering extends XmlComponent {
+    private readonly abstractNumberingMap;
+    private readonly concreteNumberingMap;
+    private readonly referenceConfigMap;
+    private readonly abstractNumUniqueNumericId;
+    private readonly concreteNumUniqueNumericId;
+    constructor(options: INumberingOptions);
+    prepForXml(context: IContext): IXmlableObject | undefined;
+    createConcreteNumberingInstance(reference: string, instance: number): void;
+    get ConcreteNumbering(): readonly ConcreteNumbering[];
+    get ReferenceConfig(): readonly Record<string, any>[];
+}

package/dist/file/numbering/numbering.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/paragraph/formatting/alignment.d.ts

@@ -0,0 +1,17 @@
+import { XmlComponent } from '../../xml-components';
+export declare const AlignmentType: {
+    readonly START: "start";
+    readonly CENTER: "center";
+    readonly END: "end";
+    readonly BOTH: "both";
+    readonly MEDIUM_KASHIDA: "mediumKashida";
+    readonly DISTRIBUTE: "distribute";
+    readonly NUM_TAB: "numTab";
+    readonly HIGH_KASHIDA: "highKashida";
+    readonly LOW_KASHIDA: "lowKashida";
+    readonly THAI_DISTRIBUTE: "thaiDistribute";
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+    readonly JUSTIFIED: "both";
+};
+export declare const createAlignment: (type: (typeof AlignmentType)[keyof typeof AlignmentType]) => XmlComponent;

package/dist/file/paragraph/formatting/alignment.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file/paragraph/formatting/border.d.ts

@@ -0,0 +1,15 @@
+import { IBorderOptions } from '../../border';
+import { IgnoreIfEmptyXmlComponent, XmlComponent } from '../../xml-components';
+export type IBordersOptions = {
+    readonly top?: IBorderOptions;
+    readonly bottom?: IBorderOptions;
+    readonly left?: IBorderOptions;
+    readonly right?: IBorderOptions;
+    readonly between?: IBorderOptions;
+};
+export declare class Border extends IgnoreIfEmptyXmlComponent {
+    constructor(options: IBordersOptions);
+}
+export declare class ThematicBreak extends XmlComponent {
+    constructor();
+}