> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reducto.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Paragraph

## `Paragraph`

The formatting half of Paragraph: style, alignment, spacing, indents, pagination and lists.

Import from `@reductoai/docx/node`, `@reductoai/docx/officejs`.

### Paragraph properties

| Name | Type | Description |
| - | - | - |
| `alignment` | `Alignment` | Effective alignment, the one Word paints: direct `w:jc`, else the style chain's, else the docDefaults', else Left. Unknown only for a jc value with no OfficeJS name; null on write removes the direct `w:jc`. |
| `borders` | `BorderUniversalCollection` | read-only office.js Paragraph.borders: Top, Left, Bottom, Right, Between, in that order. |
| `contentControls` | `ContentControlCollection` | read-only |
| `dropCap` | `DropCap` | read-only VBA Paragraph.DropCap as a Word.DropCap: the framed initial that starts this paragraph. |
| `endnotes` | `HandleCollection<NoteItem>` | read-only office.js Paragraph.endnotes: the endnotes whose reference mark sits in this paragraph. |
| `equations` | `HandleCollection<Equation>` | read-only Extension: the equations in this paragraph, read and rewritten as TeX. |
| `fields` | `FieldCollection` | read-only Fields whose begin anchor sits in this paragraph, in document order. |
| `firstLineIndent` | `number` | First-line indent in points: positive is a first-line indent, negative a hanging indent (the OfficeJS convention). Reads direct w:ind, falling back to the paragraph style's chain, else 0; null clears the direct one. |
| `font` | `Font` | read-only Run formatting over the paragraph's whole text; write is a no-op when empty. |
| `footnotes` | `HandleCollection<NoteItem>` | read-only office.js Paragraph.footnotes: the footnotes whose reference mark sits in this paragraph. |
| `frame` | `ParagraphFrame \| undefined` | The paragraph's direct text frame or drop cap (`w:framePr`; extension, VBA's `Frame` and `DropCap`), undefined when it has none. Setting replaces the frame; null removes it. |
| `hasPageBreak` | `boolean` | read-only Readback for insertBreak("Page"): true when any run carries an explicit page break (`w:br w:type="page"`). Page breaks NEVER show in `text`, and no other property accounts for them — a paragraph whose every readable property is clean can still end the page here. Check this before reasoning about why content refuses to share a page. |
| `inlinePictures` | `HandleCollection<InlinePicture>` | read-only |
| `isBlank` | `boolean` | read-only True when the paragraph carries neither text nor inline ink. |
| `isLastParagraph` | `boolean` | read-only Whether this is the final paragraph in its parent body or table cell. |
| `isListItem` | `boolean` | read-only True when the paragraph belongs to a list — its rendered marker is not in `text`. |
| `keepTogether` | `boolean` | Keep all lines of this paragraph on one page (`w:keepLines`; extension, VBA's `KeepTogether`): direct, else the style chain, else false. |
| `keepWithNext` | `boolean` | Keep this paragraph on the same page as the next one (`w:keepNext`; extension, VBA's `KeepWithNext`; Office.js has it on Style only): direct, else the style chain, else false. null clears the direct value. |
| `leftIndent` | `number` | Left indent in points: direct w:ind, falling back to the paragraph style's chain, so a visibly indented paragraph reads its real value. 0 when neither declares one. Writes are direct; null removes the direct one. |
| `lineSpacing` | `number` | Effective line spacing as Word's API counts it: direct, else the style chain and docDefaults, else 12 (single). Under the Multiple rule (the default) 12 is one line of the paragraph's font, so 84 lays seven lines, not 84 points; for a fixed pitch use setLineSpacing(\{ rule: "Exactly", points }). Writing null removes the direct value. |
| `lineSpacingRule` | `LineSpacingRule` | read-only How lineSpacing reads: Multiple (Word's auto), Exactly or AtLeast; effective through the style chain. |
| `lineUnitAfter` | `number \| undefined` | Direct spacing after this paragraph, measured in document-grid lines. |
| `lineUnitBefore` | `number \| undefined` | Direct spacing before this paragraph, measured in document-grid lines. |
| `list` | `List` | read-only Gets the list to which this paragraph belongs. |
| `listItem` | `ListItem` | read-only Gets this paragraph's list item, matching OfficeJS's throwing property. |
| `listItemOrNullObject` | `ListItem & { isNullObject: boolean }` | read-only This paragraph's list item, or an OfficeJS null object when it is plain text. |
| `listOrNullObject` | `List & { isNullObject: boolean }` | read-only This paragraph's list, or an OfficeJS null object when it is plain text. |
| `noSpaceBetweenParagraphsOfSameStyle` | `boolean` | Word's "Don't add space between paragraphs of the same style" on this paragraph (`w:contextualSpacing`; extension, Office.js has it on Style only): direct, else the style chain, else false. null clears the direct value. |
| `outlineLevel` | `number` | Effective Word outline level (1..9 are headings, 10 is body text): the direct `w:outlineLvl`, else the style chain's, else the heading style's own level. |
| `pageBreakBefore` | `boolean` | Start this paragraph on a fresh page (`w:pPr/w:pageBreakBefore`). The read reports the DIRECT property only: a style's page break does not show here, though the renderer honours it. Writing false removes the element. This property is NOT the only way a paragraph pins to a page: a run-level `w:br w:type="page"` never shows in `text` — read `hasPageBreak`. |
| `parentBody` | `Body` | read-only Closest body scope: the containing cell body, or the main document body. |
| `parentContentControl` | `ContentControl` | read-only |
| `parentContentControlOrNullObject` | `ContentControl` | read-only |
| `parentSection` | `Section` | read-only The section whose page setup lays this paragraph — an extension for multi-section documents (Body.parentSection reports the terminal section only). The paragraph's own w:sectPr when its mark carries a section break, else the first break at or after its top-level block, else the final body-level section. Header, footer, and note paragraphs belong to no body section: this throws ItemNotFound. |
| `parentSectionOrNullObject` | `Section & { isNullObject: boolean }` | read-only |
| `parentTable` | `Table` | read-only Nearest containing table; throws ItemNotFound for a body paragraph. |
| `parentTableCell` | `TableCell` | read-only Nearest containing table cell; throws ItemNotFound for a body paragraph. |
| `parentTableCellOrNullObject` | `TableCell & { isNullObject: boolean }` | read-only |
| `parentTableOrNullObject` | `Table & { isNullObject: boolean }` | read-only |
| `rightIndent` | `number` | Right indent in points; reads like `leftIndent`, and null clears like it too. |
| `rightToLeft` | `boolean` | Effective paragraph direction, the one Word paints: direct `w:bidi`, else the style chain's (docDefaults included), else false (left-to-right). Writing either boolean emits an explicit direct property, so false turns an RTL-styled paragraph LTR; null clears it so the style shows through. |
| `shading` | `ParagraphShadingUniversal` | read-only office.js Paragraph.shading: this paragraph's `w:pPr/w:shd`, read effective. |
| `shapes` | `HandleCollection<Shape>` | read-only Floating textboxes and pictures anchored to this paragraph. |
| `spaceAfter` | `number` | Effective space after the paragraph, in points: direct, else the style chain, else Word's 0. Writing null removes the direct `w:spacing` value. |
| `spaceBefore` | `number` | Effective space before the paragraph, in points: direct, else the style chain, else Word's 0. Writing null removes the direct `w:spacing` value. |
| `style` | `string \| undefined` | The paragraph's style name ("Heading 1"): its direct w:pStyle, or the document default paragraph style (usually "Normal") like OfficeJS. Accepts a style name, style ID, or OfficeJS BuiltInStyleName spelling on write; a Word built-in the document never defined is injected with its factory definition, like Word's own lazy built-ins. |
| `styleBuiltIn` | `string \| undefined` | OfficeJS spelling: reads the Word built-in name ("Heading1" even when the document's ID is localized, e.g. "Nadpis1"), falling back to the raw style ID for custom styles; writes like `style`. |
| `tableNestingLevel` | `number` | read-only Number of containing tables; body paragraphs are level zero. |
| `tabStops` | `TabStop[]` | Extension: the paragraph's own tab stops (`w:pPr/w:tabs`), positions in points and sorted. Reads only DIRECT stops — a style's are Style.paragraphFormat.tabStops. Writing REPLACES the set; an empty array or null removes it. |
| `text` | `string` | read-only |
| `uniqueLocalId` | `string` | read-only A GUID built from the paragraph's `w14:paraId`: the same after a save, a reload or a Word round trip (an extension; Word's changes on each launch). Find it with `getParagraphByUniqueLocalId`. |
| `widowControl` | `boolean` | Widow and orphan control (`w:widowControl`; extension, VBA's `WidowControl`): direct, else the style chain, else false. |

### `Paragraph.of()`

```ts theme={null}
static of(ctx: FacadeContext, element: XElement): Paragraph
```

The handle of `element` under `ctx`, made once.

### `Paragraph.attachToList()`

```ts theme={null}
attachToList(listId: number, level?: number): List
```

Join an existing list (another paragraph's `list.id`) at `level`.

### `Paragraph.clear()`

```ts theme={null}
clear(): void
```

Remove the paragraph's text, keeping the paragraph itself.

### `Paragraph.closeUp()`

```ts theme={null}
closeUp(): void
```

Remove direct spacing before this paragraph.

### `Paragraph.delete()`

```ts theme={null}
delete(): void
```

### `Paragraph.detachFromList()`

```ts theme={null}
detachFromList(): void
```

Remove this paragraph's list membership, keeping its text where the marker sat.

### `Paragraph.endSection()`

```ts theme={null}
endSection(breakType?: SectionBreakType): void
```

Extension: end the section at this paragraph's own mark, so no carrier
paragraph is added. The next section starts the way `breakType` says.

### `Paragraph.format()`

```ts theme={null}
format(format: ParagraphFormat): void
```

Direct formatting scoped to this exact paragraph, including cells and textboxes.

### `Paragraph.getComments()`

```ts theme={null}
getComments(): CommentCollection
```

office.js Paragraph.getComments: the comments the whole paragraph's range holds.

### `Paragraph.getContentControls()`

```ts theme={null}
getContentControls(options?: ContentControlOptions): ContentControlCollection
```

office.js Paragraph.getContentControls: the whole paragraph's range, options and all.

### `Paragraph.getHtml()`

```ts theme={null}
getHtml(): ClientResult<string>
```

As Word: `<h1>-<h6>` for a heading, the list marker as text, b/i/u/s/sup/sub and links inline.

### `Paragraph.getNext()`

```ts theme={null}
getNext(): Paragraph
```

The next paragraph in this scope (body or cell; body-level tables are skipped).

### `Paragraph.getNextOrNullObject()`

```ts theme={null}
getNextOrNullObject(): Paragraph & { isNullObject: boolean }
```

The next paragraph, or an OfficeJS null object at the end of this body/cell.

### `Paragraph.getOoxml()`

```ts theme={null}
getOoxml(): ClientResult<string>
```

### `Paragraph.getPrevious()`

```ts theme={null}
getPrevious(): Paragraph
```

The previous paragraph in this scope (body or cell; body-level tables are skipped).

### `Paragraph.getPreviousOrNullObject()`

```ts theme={null}
getPreviousOrNullObject(): Paragraph & { isNullObject: boolean }
```

The previous paragraph, or an OfficeJS null object at the start of this body/cell.

### `Paragraph.getRange()`

```ts theme={null}
getRange(location?: RangeLocation): Range
```

### `Paragraph.getReviewedText()`

```ts theme={null}
getReviewedText(changeTrackingVersion?: "Original" | "Current"): ClientResult<string>
```

### `Paragraph.getText()`

```ts theme={null}
getText(
  options?: { IncludeHiddenText?: boolean; IncludeTextMarkedAsDeleted?: boolean },
): ClientResult<string>
```

### `Paragraph.getTextRanges()`

```ts theme={null}
getTextRanges(endingMarks: string[], trimSpacing?: boolean): RangeCollection<Range>
```

### `Paragraph.getTrackedChanges()`

```ts theme={null}
getTrackedChanges(): TrackedChangeCollection
```

office.js Paragraph.getTrackedChanges: every revision INSIDE this w:p, by
ELEMENT CONTAINMENT, not the range window — a tracked deletion whose
markup lands at the very end of the paragraph still belongs to it.

### `Paragraph.indent()`

```ts theme={null}
indent(): void
```

Increase direct left indentation by one Word default tab stop (0.5 inch).

### `Paragraph.indentCharacterWidth()`

```ts theme={null}
indentCharacterWidth(count: number): void
```

Move by a signed number of character-grid units.

### `Paragraph.indentFirstLineCharacterWidth()`

```ts theme={null}
indentFirstLineCharacterWidth(count: number): void
```

Move the first-line indent by a signed number of character-grid units.

### `Paragraph.insertBreak()`

```ts theme={null}
insertBreak(breakType?: BreakType, location?: SiblingInsertLocation): void
```

Insert a break before or after this paragraph. `Page`, `Line` and `Column` (an extension) become
`w:br` runs: a page break does not appear in `text` (read `hasPageBreak`),
a line break reads as "\n". The four `Section*` kinds split the paragraph
mark and author a real section break.

`Next` stays rejected: OfficeJS deprecated it without a single documented
meaning (page break in some hosts, section-on-next-page in others). Ask for
`Page` or `SectionNext` instead.

### `Paragraph.insertCanvas()`

```ts theme={null}
insertCanvas(insertShapeOptions?: InsertShapeOptions): Shape
```

Insert an empty floating drawing canvas anchored to this paragraph; geometry in points.

### `Paragraph.insertChart()`

```ts theme={null}
insertChart(spec: ChartCreateSpec, insertLocation?: "Start" | "End"): Chart
```

Insert an inline chart (extension); data comes from the spec's literal caches.

### `Paragraph.insertComment()`

```ts theme={null}
insertComment(commentText: string): Comment
```

Not an OfficeJS Paragraph member, but a named gap beats a bare TypeError.

### `Paragraph.insertContentControl()`

```ts theme={null}
insertContentControl(type?: ContentControlType): ContentControl
```

### `Paragraph.insertDiagram()`

```ts theme={null}
insertDiagram(spec: DiagramCreateSpec, insertLocation?: "Start" | "End"): Diagram
```

Insert an inline SmartArt diagram (extension); the frame is painted from a cache.

### `Paragraph.insertFileFromBase64()`

```ts theme={null}
insertFileFromBase64(
  base64File: DocxFile,
  insertLocation?: "Replace" | "Start" | "End",
): Promise<Range>
```

Insert a .docx's body at the edge (or in place of the content), with its images, links, styles,
numbering, notes and comments. Async here: unlike Word, the file is unpacked on this side.

### `Paragraph.insertFreeform()`

```ts theme={null}
insertFreeform(path: string, insertShapeOptions?: InsertShapeOptions): Shape
```

Insert a floating custom-geometry shape (extension): absolute SVG path data in points.

### `Paragraph.insertGeometricShape()`

```ts theme={null}
insertGeometricShape(
  geometricShapeType: GeometricShapeType,
  insertShapeOptions?: InsertShapeOptions,
): Shape
```

Insert a floating preset-geometry shape anchored to this paragraph; geometry in points.

### `Paragraph.insertHorizontalLine()`

```ts theme={null}
insertHorizontalLine(
  options?: HorizontalLineOptions,
  insertLocation?: "Start" | "End",
): Range
```

Insert a horizontal rule (extension; Word's Insert > Horizontal Line). It takes a whole
line and spans the column; returns the range of its one object character.

### `Paragraph.insertHtml()`

```ts theme={null}
insertHtml(html: string, insertLocation?: ParagraphContentLocation): Range
```

Insert a strict named subset of HTML. Before/After author sibling blocks;
Start/End place run-level content at this paragraph's text edges and
reject block-level HTML; Replace swaps this paragraph's text (run-level
payload) or the paragraph itself (block-level payload), like insertOoxml.

### `Paragraph.insertHyperlink()`

```ts theme={null}
insertHyperlink(options: InsertHyperlinkOptions): void
```

Insert an external hyperlink; `offset` is UTF-16 within this paragraph's text.

### `Paragraph.insertImage()`

```ts theme={null}
insertImage(options: InsertImageOptions): void
```

Insert an inline image; `offset` is UTF-16 within this paragraph's text.

### `Paragraph.insertInlinePictureFromBase64()`

```ts theme={null}
insertInlinePictureFromBase64(
  base64: string,
  insertLocation: "Start" | "End",
  options?: InsertInlinePictureOptions,
): InlinePicture
```

### `Paragraph.insertLine()`

```ts theme={null}
insertLine(
  connectorType?: "Straight" | "Elbow" | "Curve",
  options?: InsertShapeOptions,
): Shape
```

Insert a floating line or connector (extension; PowerPoint's `addLine`); points.

### `Paragraph.insertListItem()`

```ts theme={null}
insertListItem(
  text: string,
  options?: Omit<OfficeRunFormat<InsertListItemOptions>, "text">,
): Paragraph
```

Insert a list item after this paragraph, continuing or starting a list.
To append at the end of an existing list, use `list.insertParagraph(text, "End")`.

### `Paragraph.insertMath()`

```ts theme={null}
insertMath(...__namedParameters: InsertMathArgs<ParagraphContentLocation>): Range
```

Extension: TeX math as a native Office Math equation, at insertOoxml's anchors.

### `Paragraph.insertOoxml()`

```ts theme={null}
insertOoxml(ooxml: string, insertLocation?: ParagraphContentLocation): Range
```

Insert a WML fragment or a Word `pkg:package` payload. Before/After author
sibling blocks; Start/End place run-level content at this paragraph's text
edges and reject block-level content. Replace swaps this paragraph's text
in place for a run-level payload (its pPr survives) and replaces the whole
paragraph for a block-level one.

### `Paragraph.insertParagraph()`

```ts theme={null}
insertParagraph(
  text: string,
  location?: SiblingInsertLocation,
  options?: Omit<OfficeRunFormat<InsertParagraphOptions>, "text">,
): Paragraph
```

Insert a sibling paragraph after or before this one, as Office.js does: the
new paragraph keeps this one's style, numbering and paragraph formatting.
"After" hands it this paragraph's mark and types with the last character's
format; "Before" uses the first character's. `format: "plain"` starts from
document defaults. On a table cell's last paragraph, "After" goes where
Word puts it: before the next paragraph in document order (the next row's
cell, or after the table), with that paragraph's formatting. To add a
paragraph in the same cell, use `getRange("End").insertText("\n" + text, "End")`.

### `Paragraph.insertPictureFromBase64()`

```ts theme={null}
insertPictureFromBase64(base64: string, options?: FloatingPictureOptions): Shape
```

Insert a floating picture anchored to this paragraph; geometry in points.

### `Paragraph.insertScene()`

```ts theme={null}
insertScene(options: SceneOptions): Shape
```

Insert one floating group of preset shapes and connectors (an org tree, a flow); points.

### `Paragraph.insertTable()`

```ts theme={null}
insertTable(
  rowCount: number,
  columnCount: number,
  location?: SiblingInsertLocation,
  values?: string[][],
  options?: Omit<OfficeRunFormat<InsertTableOptions>, "rows">,
): Table
```

Insert a table after or before this body paragraph; `values` fills cells
row-major. Cells are born PLAIN: the table style owns their appearance, so
no run formatting is cloned from the anchor paragraph. Pass
`format: "clone"` to seed cell text from the anchor instead.

### `Paragraph.insertText()`

```ts theme={null}
insertText(
  text: string,
  location?: TextInsertLocation,
  format?: OfficeRunFormatInput,
): Range
```

Insert into this paragraph's own text. `"Replace"` swaps the whole
paragraph text in place — on a blank paragraph that is the fill-the-blank
primitive. Newlines split into sibling paragraphs cloned from this one.
Returns the range covering the inserted text (its first line, if several).

### `Paragraph.insertTextBox()`

```ts theme={null}
insertTextBox(text?: string, options?: TextBoxOptions): Shape
```

Insert a floating textbox anchored to this paragraph; geometry is in points.

### `Paragraph.insertTextEffect()`

```ts theme={null}
insertTextEffect(
  text: string,
  options: TextEffectOptions,
  insertLocation?: "Start" | "End",
): Range
```

Insert legacy WordArt: the text stretched over a box (extension; VBA's
`Shapes.AddTextEffect`, which Word's text watermark uses). Returns the range of its
one object character.

### `Paragraph.moveTo()`

```ts theme={null}
moveTo(target: Paragraph, location?: MoveLocation, options?: MoveOptions): Paragraph
```

Move this paragraph (through `options.through`, a later sibling, for a
multi-paragraph clause) before or after another paragraph. With change
tracking on the move is recorded as Word's Moved From / Moved To pair.
Returns the paragraph now at the destination.

### `Paragraph.next()`

```ts theme={null}
next(count?: number): Paragraph
```

Return the paragraph `count` siblings forward in the same parent scope.

### `Paragraph.openOrCloseUp()`

```ts theme={null}
openOrCloseUp(): void
```

Toggle direct space-before between zero and twelve points.

### `Paragraph.openUp()`

```ts theme={null}
openUp(): void
```

Set direct space-before to twelve points.

### `Paragraph.outdent()`

```ts theme={null}
outdent(): void
```

Remove one Word default tab-stop level, stopping at the left margin.

### `Paragraph.outlineDemote()`

```ts theme={null}
outlineDemote(): void
```

Apply the next heading style; Heading 9 demotes to Normal body text.

### `Paragraph.outlineDemoteToBody()`

```ts theme={null}
outlineDemoteToBody(): void
```

Demote the paragraph to body text by applying Normal.

### `Paragraph.outlinePromote()`

```ts theme={null}
outlinePromote(): void
```

Apply the previous heading style; body text promotes to Heading 9.

### `Paragraph.previous()`

```ts theme={null}
previous(count?: number): Paragraph
```

Return the paragraph `count` siblings backward in the same parent scope.

### `Paragraph.reset()`

```ts theme={null}
reset(): void
```

Remove direct paragraph formatting while retaining style, list, and section identity.

### `Paragraph.search()`

```ts theme={null}
search(needle: string, options?: SearchOptions): RangeCollection<Range>
```

### `Paragraph.set()`

```ts theme={null}
set(properties: ParagraphUpdateData, options?: UpdateOptions): void
```

### `Paragraph.setLineSpacing()`

```ts theme={null}
setLineSpacing(spec: LineSpacingSpec): void
```

Rule and value in one write: Exactly / AtLeast take the pitch in points, Multiple a count of lines.

### `Paragraph.space1()`

```ts theme={null}
space1(): void
```

### `Paragraph.space1Pt5()`

```ts theme={null}
space1Pt5(): void
```

### `Paragraph.space2()`

```ts theme={null}
space2(): void
```

### `Paragraph.split()`

```ts theme={null}
split(
  delimiters: string[],
  trimDelimiters?: boolean,
  trimSpacing?: boolean,
): RangeCollection<Range>
```

Office.js Paragraph.split: the paragraph's text cut after each delimiter.

### `Paragraph.startNewList()`

```ts theme={null}
startNewList(
  format?: "none" | "bullet" | "decimal" | "decimalZero" | "lowerLetter" | "upperLetter" | "lowerRoman" | "upperRoman" | "hebrew1" | "hebrew2",
  level?: number,
): List
```

Make this paragraph the first item of a new list; pass `list.id` to
attachToList. `format` is a raw OOXML `w:numFmt` token, one of: bullet,
decimal, decimalZero, lowerLetter, upperLetter, lowerRoman, upperRoman,
hebrew1, hebrew2, none. For the OfficeJS ListNumbering spellings, and to
change one level after the fact, use `list.setLevelNumbering`.

### `Paragraph.tabHangingIndent()`

```ts theme={null}
tabHangingIndent(count: number): void
```

Set a hanging indent measured in Word's default half-inch tab stops.

### `Paragraph.tabIndent()`

```ts theme={null}
tabIndent(count: number): void
```

Set the left indent measured in Word's default half-inch tab stops.

**Not implemented.** These Office.js members throw: `getAnnotations`, `insertAnnotations`, `joinList`, `resetAdvanceTo`, `select`, `selectNumber`, `separateList`.

## `ParagraphCollection`

OfficeJS-flavored live collection: `items` is recomputed on every access.

Import from `@reductoai/docx/node`, `@reductoai/docx/officejs`.

### ParagraphCollection properties

| Name | Type | Description |
| - | - | - |
| `items` | `T[]` | read-only |
| `length` | `number` | read-only |

### `ParagraphCollection.add()`

```ts theme={null}
add(range: ParagraphRangeLike<T>): T
```

Insert a new blank paragraph immediately before `range`.

### `ParagraphCollection.at()`

```ts theme={null}
at(index: number): T
```

### `ParagraphCollection.closeUp()`

```ts theme={null}
closeUp(): void
```

### `ParagraphCollection.decreaseSpacing()`

```ts theme={null}
decreaseSpacing(): void
```

### `ParagraphCollection.getFirst()`

```ts theme={null}
getFirst(): T
```

### `ParagraphCollection.getFirstOrNullObject()`

```ts theme={null}
getFirstOrNullObject(): T & { isNullObject: boolean }
```

OfficeJS null-object variant; inspect `isNullObject` before other members.

### `ParagraphCollection.getItem()`

```ts theme={null}
getItem(index: number): T
```

OfficeJS spelling of at().

### `ParagraphCollection.getLast()`

```ts theme={null}
getLast(): T
```

### `ParagraphCollection.getLastOrNullObject()`

```ts theme={null}
getLastOrNullObject(): T & { isNullObject: boolean }
```

OfficeJS null-object variant; inspect `isNullObject` before other members.

### `ParagraphCollection.increaseSpacing()`

```ts theme={null}
increaseSpacing(): void
```

### `ParagraphCollection.indent()`

```ts theme={null}
indent(): void
```

### `ParagraphCollection.indentCharacterWidth()`

```ts theme={null}
indentCharacterWidth(count: number): void
```

### `ParagraphCollection.indentFirstLineCharacterWidth()`

```ts theme={null}
indentFirstLineCharacterWidth(count: number): void
```

### `ParagraphCollection.openOrCloseUp()`

```ts theme={null}
openOrCloseUp(): void
```

### `ParagraphCollection.openUp()`

```ts theme={null}
openUp(): void
```

### `ParagraphCollection.outdent()`

```ts theme={null}
outdent(): void
```

### `ParagraphCollection.outlineDemote()`

```ts theme={null}
outlineDemote(): void
```

### `ParagraphCollection.outlineDemoteToBody()`

```ts theme={null}
outlineDemoteToBody(): void
```

### `ParagraphCollection.outlinePromote()`

```ts theme={null}
outlinePromote(): void
```

### `ParagraphCollection.space1()`

```ts theme={null}
space1(): void
```

### `ParagraphCollection.space1Pt5()`

```ts theme={null}
space1Pt5(): void
```

### `ParagraphCollection.space2()`

```ts theme={null}
space2(): void
```

### `ParagraphCollection.tabHangingIndent()`

```ts theme={null}
tabHangingIndent(count: number): void
```

### `ParagraphCollection.tabIndent()`

```ts theme={null}
tabIndent(count: number): void
```
