@pptx-editor.dev/core/contracts

AltTextinterfaceSource ↗

The alt text of an element (p:cNvPr).

interface AltText

AnimationEffect_2interface

One effect of a slide, in the order the slide plays it.

interface AnimationEffect

BulletFormatMixedinterfaceSource ↗

What the selected paragraphs share when their bullet formats differ, so the Bullets and Numbering dialog opens on their list's tab and shows the values they have in common.

interface BulletFormatMixed

ChartColorEntryinterfaceSource ↗

The color of one series, or of one data point of a pie or doughnut chart.

interface ChartColorEntry

ChartDatainterfaceSource ↗

The data of one chart: its categories and its series.

interface ChartData

ChartDataCategoryinterfaceSource ↗

One category (or X value) of a chart.

interface ChartDataCategory

ChartDataSeriesinterfaceSource ↗

One series of a chart.

interface ChartDataSeries

ChartFormatinterfaceSource ↗

The type and elements of a chart, as chartFormat reads them. A field is null when the chart type has no such element: a pie chart has no axes.

interface ChartFormat

ChartFormatChangeinterfaceSource ↗

The chart elements that setChartFormat changes. An absent field keeps its value. A title of null removes the title; a string sets its text and keeps its formatting.

interface ChartFormatChange

ClipboardNodeinterfaceSource ↗

A serialized element, structurally the store's NodeSpec.

interface ClipboardNode

ClipboardPayloadinterfaceSource ↗

The clipboard format for shapes (application/x-pptx-editor+json).

interface ClipboardPayload

ClipboardRelationshipinterfaceSource ↗

A relationship a copied shape uses, with the bytes of its target. A chart, a diagram, or an embedded object carries its own relationships in relationships. A web link carries its address in target and no bytes. A link to a slide names the slide part and carries no bytes; paste keeps it only in the presentation it came from.

interface ClipboardRelationship

CommentAuthorInputinterfaceSource ↗

Who writes a comment or a reply. Absent, the editor's author option (setAuthor) applies, then the collaboration identity. Without a name, the command is refused (disabled.noCommentAuthor).

interface CommentAuthorInput

CommentExpectinterfaceSource ↗

What a host showed of a comment, for a command that acts on it: pass the comment's author, date, text, and identity as the snapshot gave them. The editor refuses the command (errors.commentChanged) when the comment at commentId has another author or date.

A twin shares its GUID, author, and creation time with another comment of the slide, or, in the legacy format, its author and index. A twin's id holds its place among its twins (~<n>, or -<n> for a legacy comment). For an id with a place, the editor also compares the text (errors.commentChanged), and refuses the command when the comment has no twin left (errors.noComment): the id may have named the twin that is gone.

Without identity, an id with a place is also refused when another twin has the same text (errors.commentAmbiguous), and when it named another comment since the last snapshot (errors.commentChanged, until the next snapshot). With identity, the editor checks it instead. So a collaborator's edit of a comment without a twin never refuses yours.

Always pass identity. Without it, after the next snapshot, an old id can reach another twin with the same author, date, and text.

interface CommentExpect

CommentSnapshotinterfaceSource ↗

The comment fields of the editor snapshot (EditorSnapshot).

interface CommentSnapshot

CommentTextRangeinterfaceSource ↗

A range of a shape's text, with the points that a text selection (EditorSelection) uses. A snapshot gives start before end. addComment takes the two points in either order.

interface CommentTextRange

CommentThreadinterfaceSource ↗

A comment and its replies (EditorSnapshot.comments).

interface CommentThread extends SlideComment

ConnectionTargetinterfaceSource ↗

A connection site of a shape: the shape's node id and the site's index.

interface ConnectionTarget

ConnectorRouteinterfaceSource ↗

A connector's route and the shapes its ends glue to. Each field is optional: an absent field keeps the connector's current value.

interface ConnectorRoute

CustomShowSummaryinterfaceSource ↗

A custom show of the deck (p:custShow, ECMA-376 Part 1, 19.2.1.7), for links.

interface CustomShowSummary

DateTimeStateinterfaceSource ↗

The date that the slides show (EditorSnapshot.dateTime).

interface DateTimeState

DiagramNodeStateinterfaceSource ↗

One node of the selected diagram, in outline order.

interface DiagramNodeState

DocumentOpenFailureinterfaceSource ↗

A file the editor refused to open. It carries a stable code only, never the file's content or name. Each refusal is a new object, so a host can tell a second refusal of the same file from the first.

interface DocumentOpenFailure

EditorinterfaceSource ↗

The editor contract adapters render.

interface Editor

EditorFontSubstitutioninterfaceSource ↗

A family the deck names that renders with another face.

interface EditorFontSubstitution

EditorRejectioninterfaceSource ↗

A refused edit: the i18n key of the reason and an optional detail.

interface EditorRejection

EditorRemovalinterfaceSource ↗

A Delete that the user can undo: what it removed and how many.

interface EditorRemoval

EditorSnapshotinterfaceSource ↗

interface EditorSnapshot extends CommentSnapshot

FindMatchinterfaceSource ↗

One match of a find. Offsets are UTF-16 offsets in the paragraph.

interface FindMatch

FindOptionsinterfaceSource ↗

How find compares text.

interface FindOptions

FontConfigurationinterfaceSource ↗

Public font source configuration sampled when an adapter mounts. It must be immutable for that editor lifetime; remount the adapter to replace bytes or substitutions atomically.

interface FontConfiguration

FontFaceRequestinterfaceSource ↗

A concrete font face requested by authored document content.

interface FontFaceRequest

FontFormatCommandinterfaceSource ↗

The fields of the Font dialog (Font and Character Spacing tabs), as setFontFormat takes them. An omitted field keeps each run's value. The same shape as ParagraphFormatCommand.

interface FontFormatCommand

FontFormatReadinterfaceSource ↗

The selected text as the Font dialog reads it: resolved values. A field is null when the selected runs disagree (disagrees says which), so a control can show a blank.

interface FontFormatRead

FontSourceinterfaceSource ↗

Immutable, byte-backed font face supplied to layout and browser paint.

interface FontSource

FontSourceSubstitutioninterfaceSource ↗

An explicit authored-font substitution. No implicit platform fallback is performed.

interface FontSourceSubstitution

GradientFillinterfaceSource ↗

A gradient fill as the chrome edits it.

interface GradientFill

HeaderFooterTargetsinterfaceSource ↗

The slides that setSlideNumbers, setFooter, and setDateTime act on.

interface HeaderFooterTargets

HistoryGroupinterfaceSource ↗

The engine-owned identity of one gesture. Create it with Editor.beginHistoryGroup().

Every command that names one open handle becomes part of one undo step. Undo, redo, and a command with another handle (or none) close the step, so a later command with the handle starts a new one. A selection change, and a command that the editor refuses before it writes, leave the step open. Redo restores the selection after the last command of the step.

interface HistoryGroup

HistoryGroupOptionsinterfaceSource ↗

Options for a command that can join an explicit history group.

interface HistoryGroupOptions

```ts
const resize = editor.beginHistoryGroup();
editor.exec({ type: 'setTableGrid', columns: [914400, 914400] }, { historyGroup: resize });
editor.exec({ type: 'setTableGrid', columns: [1828800, 914400] }, { historyGroup: resize });
resize.end();
editor.exec({ type: 'undo' }); // reverts both commands
```

ImageAdjustmentsinterfaceSource ↗

Picture corrections, color, and transparency, as the Picture Format tab sets them.

interface ImageAdjustments

ImageCropPercentinterfaceSource ↗

The crop of each edge of a picture, in percent of the image (a:srcRect), after DOCX Editor's ImageCropPercent: a positive value removes that part of the image. Unlike DOCX Editor's 0 to 100, a value may be negative: it adds space on that side as padding (Fit writes it).

interface ImageCropPercent

ImagePropertiesinterfaceSource ↗

The Format Picture values, as DOCX Editor's setImageProperties names them. The size is the size on the slide, as the Size fields show it (SelectedImageState.widthEmu; inside a scaled group it differs from the file's a:ext), and keeps the top-left corner of the unrotated box; the crop keeps the image fixed on the slide.

interface ImageProperties

LoadOptionsinterfaceSource ↗

Options of Editor.load.

interface LoadOptions

NewChartDatainterfaceSource ↗

The data of a new chart: its categories (or X values) and its series.

interface NewChartData

NotesParagraphinterfaceSource ↗

One paragraph of the speaker notes.

interface NotesParagraph

NotesRuninterfaceSource ↗

A run of the speaker notes with its character formatting.

interface NotesRun

ParagraphFormatCommandinterfaceSource ↗

The fields of the Paragraph dialog, as setParagraphFormat takes them. An omitted field keeps the paragraph's value. null removes the paragraph's own value, so it takes the inherited value again (from the layout, the master, or the shape's list style); a zero is a value and blocks the inherited one.

interface ParagraphFormatCommand

ParagraphFormatReadinterfaceSource ↗

The selected paragraphs as the Paragraph dialog reads them. A field is null when the paragraphs disagree (disagrees says which), so a control can show a blank. Values are resolved: inherited values count.

interface ParagraphFormatRead

ParagraphLineSpacinginterfaceSource ↗

Line spacing as the Paragraph dialog sets it: a multiple of single spacing (a:spcPct), or exact points (a:spcPts). DOCX Editor's rule names; a:lnSpc has no "at least".

interface ParagraphLineSpacing

PatternFillinterfaceSource ↗

A preset pattern fill (a:pattFill) as the chrome edits it.

interface PatternFill

RenderThumbnailOptionsinterfaceSource ↗

Options of renderThumbnail.

interface RenderThumbnailOptions

ReviewPaneOptionsinterfaceSource ↗

The comment view settings of a review module. Every field is optional.

interface ReviewPaneOptions

SelectedChartStateinterfaceSource ↗

The selected chart, while exactly one chart frame is selected.

interface SelectedChartState

SelectedDiagramStateinterfaceSource ↗

The selected diagram, while one diagram frame is selected or holds the caret.

interface SelectedDiagramState

SelectedEquationStateinterfaceSource ↗

The selected equation: one text box with one equation is selected.

interface SelectedEquationState

SelectedImageStateinterfaceSource ↗

The selected pictures, as the picture controls show them: the values are the first picture's.

interface SelectedImageState

SelectionFormatinterfaceSource ↗

Formatting at the selection, for toolbar state.

interface SelectionFormat

SelectionGeometryinterfaceSource ↗

The selected element's geometry, for the Format panel. EMU and degrees.

interface SelectionGeometry

ShapeEffectsStateinterfaceSource ↗

The effects of the selected element as the chrome shows them. A shadow or reflection that is not a gallery preset reads other. Sizes are in points; 0 is no effect.

interface ShapeEffectsState

ShapeStyleChoiceinterfaceSource ↗

One cell of the Shape Styles gallery.

interface ShapeStyleChoice

ShapeSummaryinterfaceSource ↗

One element of the current slide, as the selection pane lists it.

interface ShapeSummary

SlideAnimationsinterfaceSource ↗

The animations and the transition of the current slide (EditorSnapshot.animations).

interface SlideAnimations

SlideBackgroundStateinterfaceSource ↗

The current slide's background, as the chrome shows it.

interface SlideBackgroundState

SlideCommentinterfaceSource ↗

One comment or reply. Its text and author come from the file: show them as text.

interface SlideComment

SlideLayoutSummaryinterfaceSource ↗

One slide layout of the deck, as the Layout and New Slide galleries list it.

interface SlideLayoutSummary

SlideSectioninterfaceSource ↗

One section of the slide list (p14:section).

interface SlideSection

SlideSummaryinterfaceSource ↗

One slide in the rail.

interface SlideSummary

SlideTransitionStateinterfaceSource ↗

The transition of a slide (p:transition).

interface SlideTransitionState

TableBorderPeninterfaceSource ↗

The border pen: the line the Borders menu draws, and the target it last drew. A pen color, style, or weight pick arms the pen and writes nothing. A border target pick draws the pen there; after it, a pen pick redraws that target with the new pen, as DOCX Editor's table chrome draft does, until No Border.

interface TableBorderPen

TableBorderSpecinterfaceSource ↗

A cell border: color, width in points, and dash. DOCX Editor's spec counts eighths of a point and names a WordprocessingML border style; a DrawingML line (a:lnL) has a width and a preset dash, so the fields follow setLineWidth and setLineDash (and Office.js BorderProperties.weight).

interface TableBorderSpec

TableCellAddressinterfaceSource ↗

A table cell by its row and column, zero-based: the shape of the cell that DOCX Editor's getSelectedTable() returns. A merged cell is addressed by its top-left grid position.

interface TableCellAddress

TableContextinterfaceSource ↗

The table of the selection, for the Table Design and Table Layout chrome: DOCX Editor's TableContext (rows, columns, rowIndex, columnIndex), with the selected cell range that a slide table selection adds.

interface TableContext

TableStyleChoiceinterfaceSource ↗

A table style the Table Styles picker offers. A deck style carries its styleName; the built-in default is builtIn with no name, so the chrome names it in the user's language.

interface TableStyleChoice

TextColumnsinterfaceSource ↗

Text columns of a shape.

interface TextColumns

TextPointinterfaceSource ↗

A caret position: paragraph index and UTF-16 offset in the paragraph.

interface TextPoint

ThemeColorChoiceinterfaceSource ↗

A theme color pick. It is written as a:schemeClr, so the color follows the theme when the theme changes. shift is the luminance variant of [ThemeSwatch](ThemeSwatch).

interface ThemeColorChoice

ThemeSwatchinterfaceSource ↗

One swatch of the theme color grid.

interface ThemeSwatch

TransformIteminterfaceSource ↗

One element's new box, in its file coordinates (its parent's child space).

interface TransformItem

AnimationClasstypeSource ↗

The class of an effect (p:cTn/@presetClass): entrance (entr), emphasis (emph), exit (exit), motion path (path), or another class, such as a media call.

type AnimationClass = 'entrance' | 'emphasis' | 'exit' | 'motionPath' | 'other';

AnimationCommandtypeSource ↗

The animation commands.

type AnimationCommand = 
/**
 * Add an effect to each selected shape, at the end of the main sequence. A shape in a group
 * animates as its whole group. `trigger` defaults to `onClick`.
 */
{
    readonly type: 'addAnimation';
    readonly preset: AnimationPreset;
    readonly trigger?: AnimationTrigger;
}
/** Remove the effect `effectId` (`AnimationEffect.id`) of the current slide. */
 | {
    readonly type: 'removeAnimation';
    readonly effectId: string;
}
/** Move the effect `effectId` to position `to` of the main sequence (0-based). */
 | {
    readonly type: 'moveAnimation';
    readonly effectId: string;
    readonly to: number;
}
/**
 * Change when the effect `effectId` starts and how long it plays. Absent fields stay. Delay is
 * 0 to 3,600,000 ms; duration is 10 to 59,000 ms and is refused for an instant effect.
 */
 | {
    readonly type: 'setAnimationTiming';
    readonly effectId: string;
    readonly trigger?: AnimationTrigger;
    readonly delayMs?: number;
    readonly durationMs?: number;
}
/**
 * Set the transition of the current slide, or of the slides `indices`. Absent fields keep
 * their values. `kind: 'none'` removes the effect. Duration is 10 to 59,000 ms;
 * `advanceAfterMs` is 0 to 3,600,000 ms, or null to clear it.
 */
 | {
    readonly type: 'setTransition';
    readonly kind?: TransitionKind | 'none';
    readonly durationMs?: number;
    readonly advanceOnClick?: boolean;
    readonly advanceAfterMs?: number | null;
    readonly indices?: readonly number[];
}
/**
 * Show the order number of each effect on its shape on the canvas. A view setting, not an
 * edit: no undo step, never saved.
 */
 | {
    readonly type: 'showAnimationOrder';
    readonly show: boolean;
};

AnimationPresettypeSource ↗

The effects that addAnimation writes. Entrance: appear, fade, flyIn, wipe, zoom. Emphasis: pulse, spin, growShrink. Exit: disappear, fadeOut, flyOut, wipeOut, zoomOut.

type AnimationPreset = 'appear' | 'fade' | 'flyIn' | 'wipe' | 'zoom' | 'pulse' | 'spin' | 'growShrink' | 'disappear' | 'fadeOut' | 'flyOut' | 'wipeOut' | 'zoomOut';

AnimationTriggertypeSource ↗

When an effect starts (p:cTn/@nodeType): on a click (clickEffect), with the effect before it (withEffect), or after the effect before it (afterEffect).

type AnimationTrigger = 'onClick' | 'withPrevious' | 'afterPrevious';

AutonumberSchemetypeSource ↗

Numbering schemes the editor sets: the ST_TextAutonumberScheme values that layout numbers exactly. Arabic, Roman, and Latin letters with a period, a right parenthesis, or both parentheses, and Arabic numbers with nothing (arabicPlain; the schema has no other plain scheme).

type AutonumberScheme = `${'arabic' | 'romanUc' | 'romanLc' | 'alphaUc' | 'alphaLc'}${'Period' | 'ParenR' | 'ParenBoth'}` | 'arabicPlain';

BevelPresettypeSource ↗

The presets of the Bevel gallery: the top bevel presets of ST_BevelPresetType (ECMA-376 Part 1, 20.1.10.9), each 6 pt wide and 6 pt high.

type BevelPreset = 'circle' | 'relaxedInset' | 'cross' | 'coolSlant' | 'angle' | 'softRound' | 'convex' | 'slope' | 'divot' | 'riblet' | 'hardEdge' | 'artDeco';

BulletFormattypeSource ↗

A bullet format: a bullet character in a font (a:buChar, a:buFont), or a numbering scheme (a:buAutoNum), with its size and color. An omitted field keeps each paragraph's value, so a command can change only the size, the color, or the start number. With no kind, only the size and color change, on the paragraphs that show a list, and each keeps its own bullet or number. A paragraph with no list takes the bullet its placeholder inherits, or the first gallery item; one with the other kind takes the first gallery item for an omitted character or scheme. null makes the bullet follow the text (a:buSzTx, a:buClrTx), also over a list style that sets a value.

type BulletFormat = {
    readonly kind: 'bullet';
    readonly char?: string;
    readonly font?: string;
    readonly sizePercent?: number | null;
    readonly color?: ColorChoice | null;
} | {
    readonly kind: 'number';
    readonly scheme?: AutonumberScheme;
    readonly startAt?: number;
    readonly sizePercent?: number | null;
    readonly color?: ColorChoice | null;
} | {
    readonly kind: 'picture';
    readonly picture: Uint8Array;
    readonly sizePercent?: number | null;
} | {
    readonly kind?: undefined;
    readonly sizePercent?: number | null;
    readonly color?: ColorChoice | null;
};

BulletFormatReadtypeSource ↗

The bullet format of the selected paragraphs, as the gallery and dialog show it: resolved values.

type BulletFormatRead = {
    readonly kind: 'bullet';
    readonly char: string;
    readonly font?: string;
    readonly sizePercent: number;
    readonly color?: string;
} | {
    readonly kind: 'number';
    readonly scheme: string;
    readonly startAt: number;
    readonly sizePercent: number;
    readonly color?: string;
} | {
    readonly kind: 'picture';
    readonly sizePercent: number;
};

CanResulttypeSource ↗

Whether a command can run now; when it cannot, the i18n key of the reason.

type CanResult = {
    readonly ok: true;
} | {
    readonly ok: false;
    readonly reason: string;
};

CapsStyletypeSource ↗

Capitals: none, small caps, or all caps (ST_TextCapsType).

type CapsStyle = 'none' | 'small' | 'all';

CaretAffinitytypeSource ↗

The side of a direction boundary a caret shows on (TextPoint.affinity).

type CaretAffinity = 'downstream' | 'upstream';

ChartCommandtypeSource ↗

The chart commands.

type ChartCommand = {
    readonly type: 'setChartData';
    readonly nodeId?: string;
    readonly data: Omit<ChartData, 'workbook'>;
} | {
    readonly type: 'insertChart';
    readonly chartType: ChartType;
    readonly data?: NewChartData;
} | {
    readonly type: 'setChartType';
    readonly nodeId?: string;
    readonly chartType: ChartType;
} | {
    readonly type: 'setChartFormat';
    readonly nodeId?: string;
    readonly format: ChartFormatChange;
} | {
    readonly type: 'setChartColor';
    readonly nodeId?: string;
    readonly index: number;
    readonly color: ColorChoice | null;
};

ChartDataKindtypeSource ↗

How a chart plots its data. category: each series has one value per category (bar, column, line, area, pie, doughnut, and radar charts). xy: each series has one Y value per X value (scatter charts); the categories are the X values.

type ChartDataKind = 'category' | 'xy';

ChartDataReadtypeSource ↗

The data of a chart, or why it cannot be edited. reason is a translation key, such as errors.chartData.unsupportedType.

type ChartDataRead = {
    readonly ok: true;
    readonly data: ChartData;
} | {
    readonly ok: false;
    readonly reason: string;
};

ChartFormatReadtypeSource ↗

The type and elements of a chart, or why the editor does not edit them. reason is a translation key, such as errors.chartData.combination.

type ChartFormatRead = {
    readonly ok: true;
    readonly format: ChartFormat;
} | {
    readonly ok: false;
    readonly reason: string;
};

ChartLegendPositiontypeSource ↗

Where a chart shows its legend (c:legendPos), or none for no legend.

type ChartLegendPosition = 'none' | 'top' | 'bottom' | 'left' | 'right';

ChartTypetypeSource ↗

A chart type that insertChart and setChartType write (ECMA-376 Part 1, 21.2.2): the plot element, and its direction, grouping, or style. Column and bar charts are c:barChart with vertical or horizontal bars; lineMarkers shows a marker at each point; scatter shows markers only, and scatterLines joins them with lines.

type ChartType = 'columnClustered' | 'columnStacked' | 'columnPercentStacked' | 'barClustered' | 'barStacked' | 'barPercentStacked' | 'line' | 'lineMarkers' | 'area' | 'areaStacked' | 'areaPercentStacked' | 'pie' | 'doughnut' | 'radar' | 'scatter' | 'scatterLines';

ChartWorkbookStatetypeSource ↗

Where the chart's workbook is, and what an edit does to it. embedded: an edit writes the new values into the embedded workbook too. kept: the embedded workbook has a structure that the editor does not change, so it keeps its old values. external: the workbook is a linked file, which the editor never opens; an edit turns off its automatic update. none: the chart has no workbook.

type ChartWorkbookState = 'embedded' | 'kept' | 'external' | 'none';

ColorChoicetypeSource ↗

A color the chrome writes: #RRGGBB (a:srgbClr) or a theme color (a:schemeClr).

type ColorChoice = string | ThemeColorChoice;

CommandResulttypeSource ↗

The outcome of a command. A refusal with noop means the command had nothing to do (nothing to undo, nothing selected): nothing changed, and nothing went wrong.

type CommandResult = {
    readonly ok: true;
} | {
    readonly ok: false;
    readonly reason: string;
    readonly detail?: string;
    readonly noop?: boolean;
};

CommentAnchortypeSource ↗

Where a thread points on its slide. text: a range of an element's text, by its node id. shape: an element of the slide, by its node id. point: a place on the slide, in EMU. slide: the slide as a whole, with no place.

A text thread follows its text through edits. When an edit removes all of its text, the thread points at the element (shape). Only the threaded format holds text anchors.

type CommentAnchor = {
    readonly kind: 'slide';
} | {
    readonly kind: 'point';
    readonly x: number;
    readonly y: number;
} | {
    readonly kind: 'shape';
    readonly nodeId: string;
} | ({
    readonly kind: 'text';
    readonly nodeId: string;
} & CommentTextRange);

CommentCommandtypeSource ↗

The comment commands. Text is 1 to 10,000 characters; a line feed starts a new paragraph. The commands on an existing comment take expect, what the host showed of that comment. A new comment uses the threaded format, unless the deck has only legacy comments.

type CommentCommand = 
/**
 * Add a thread on the current slide. With `nodeId`, it points at that element, and with
 * `nodeId` and `range`, at that range of its text. Without `nodeId`, it points at the
 * selected text of a shape, else at the selected element when one element is selected, else
 * at the slide. A deck with only legacy comments has no text anchors: the thread then points
 * at the element.
 */
({
    readonly type: 'addComment';
    readonly text: string;
    readonly nodeId?: string;
    readonly range?: CommentTextRange;
} & CommentAuthorInput)
/** Reply to the thread of `commentId` (a thread or one of its replies). */
 | ({
    readonly type: 'replyToComment';
    readonly commentId: string;
    readonly text: string;
    readonly expect?: CommentExpect;
} & CommentAuthorInput)
/** Replace the text of a comment or a reply. */
 | {
    readonly type: 'editComment';
    readonly commentId: string;
    readonly text: string;
    readonly expect?: CommentExpect;
}
/** Delete a reply, or a whole thread when `commentId` is a thread. */
 | {
    readonly type: 'deleteComment';
    readonly commentId: string;
    readonly expect?: CommentExpect;
}
/** Mark a thread resolved. Refused for the legacy format (`disabled.commentNoStatus`). */
 | {
    readonly type: 'resolveComment';
    readonly commentId: string;
    readonly expect?: CommentExpect;
}
/** Mark a resolved thread active again. */
 | {
    readonly type: 'reopenComment';
    readonly commentId: string;
    readonly expect?: CommentExpect;
};

CommentFormattypeSource ↗

The file format of a comment thread.

type CommentFormat = 'modern' | 'legacy';

CommentMarkerStyletypeSource ↗

How a comment marker on the slide looks. icon: the comment icon. initials: a badge with the thread author's initials in the author's color, the reply count, and a check mark when the thread is resolved.

type CommentMarkerStyle = 'initials' | 'icon';

DiagramCommandtypeSource ↗

The diagram commands.

type DiagramCommand = {
    readonly type: 'addDiagramShape';
    readonly position: DiagramShapePosition;
    readonly nodeId?: string;
    readonly node?: string;
} | {
    readonly type: 'deleteDiagramShape';
    readonly nodeId?: string;
    readonly node?: string;
} | {
    readonly type: 'setDiagramText';
    readonly node: string;
    readonly text: string;
    readonly nodeId?: string;
};

DiagramShapePositiontypeSource ↗

Where addDiagramShape puts the new shape: after or before the target node at its level, or below it as its last child.

type DiagramShapePosition = 'after' | 'before' | 'below';

DocumentOpenFailureReasontypeSource ↗

What a person can do about a file that did not open, after DOCX Editor's reason groups: damaged (the archive or its XML is broken, or the file is not a ZIP package at all), not-pptx (the package holds no presentation, or the file is empty), too-large (the file crosses a size, count, or depth limit), blocked (the file uses XML features that the editor refuses for security), and unknown.

type DocumentOpenFailureReason = 'damaged' | 'not-pptx' | 'too-large' | 'blocked' | 'unknown';

EditorCommandtypeSource ↗

Every editing command. Each compiles to store ops or is refused with a reason.

type EditorCommand = CommentCommand | {
    readonly type: 'undo';
} | {
    readonly type: 'redo';
} | {
    readonly type: 'toggleBold';
} | {
    readonly type: 'toggleItalic';
} | {
    readonly type: 'toggleUnderline';
} | {
    readonly type: 'toggleStrike';
} | {
    readonly type: 'setFontSize';
    readonly points: number;
} | {
    readonly type: 'stepFontSize';
    readonly direction: 1 | -1;
} | {
    readonly type: 'setFontFamily';
    readonly family: string;
}
/** Text color: a color choice, or null for the inherited color. */
 | {
    readonly type: 'setTextColor';
    readonly color: ColorChoice | null;
} | {
    readonly type: 'setHighlight';
    readonly color: ColorChoice | null;
} | {
    readonly type: 'setAlign';
    readonly align: TextAlign;
} | {
    readonly type: 'toggleBullets';
} | {
    readonly type: 'toggleNumbering';
} | {
    readonly type: 'indent';
    readonly direction: 1 | -1;
}
/**
 * Backspace at the start of a list item: remove the bullet or number of every list item the
 * selection touches. The item keeps its level, and its text moves to where the bullet was.
 */
 | {
    readonly type: 'removeBullet';
} | {
    readonly type: 'setLineSpacing';
    readonly multiple: number;
} | {
    readonly type: 'insertTextBox';
} | {
    readonly type: 'insertShape';
    readonly preset: string;
} | {
    readonly type: 'insertImage';
    readonly bytes: Uint8Array;
    readonly mime: string;
    readonly width: number;
    readonly height: number;
} | {
    readonly type: 'order';
    readonly move: OrderMove;
} | {
    readonly type: 'alignObjects';
    readonly align: ObjectAlign;
} | {
    readonly type: 'duplicate';
} | {
    readonly type: 'delete';
}
/**
 * Home > New Slide: add a slide after the current one. `layoutId` (`SlideLayoutSummary.id`)
 * picks its layout. Without it, the slide takes the current slide's layout, or Title and
 * Content after a title slide.
 */
 | {
    readonly type: 'addSlide';
    readonly layoutId?: string;
} | {
    readonly type: 'duplicateSlide';
    readonly index: number;
}
/**
 * Paste copied slides after the current slide. `file` is a presentation (`.pptx` bytes),
 * read with the limits of any opened file, and `slides` are its slide indexes in order. The
 * slides go on this presentation's layouts of the same type (destination theme).
 */
 | {
    readonly type: 'pasteSlides';
    readonly file: Uint8Array;
    readonly slides: readonly number[];
} | {
    readonly type: 'deleteSlide';
    readonly index: number;
}
/**
 * Move slide `from` to position `to`. It joins the section of the slide before it, or
 * `section`, by the one rule of `moveSlides`. Behavior change: a slide moved up to the first
 * place of a section joined that section before; now it joins the section before it. Pass
 * that section's id as `section` to get the earlier result.
 */
 | {
    readonly type: 'moveSlide';
    readonly from: number;
    readonly to: number;
    readonly section?: string;
}
/**
 * Insert > Slide numbers: show or hide the slide number, through the slide-number placeholder
 * of each slide's layout or master. Takes the `HeaderFooterTargets` options; by default, every
 * slide. Refused, also to hide, when no target slide can have a slide number.
 */
 | ({
    readonly type: 'setSlideNumbers';
    readonly show: boolean;
} & HeaderFooterTargets)
/**
 * Insert > Footer: show or hide the footer, through the footer placeholder (`p:ph type="ftr"`)
 * of each slide's layout or master. With `text`, every slide that shows the footer shows
 * `text`. Without `text`, a slide keeps its footer text, and a slide without a footer takes the
 * text that the other slides show. A slide that has a footer keeps its box and format. Refused
 * when no target slide's layout or master has a footer placeholder, for blank or multi-line
 * text, and without `text` when no slide shows a footer (`disabled.noFooterText`). Text is one
 * line of 1,024 characters at most.
 */
 | ({
    readonly type: 'setFooter';
    readonly show: boolean;
    readonly text?: string;
} & HeaderFooterTargets)
/**
 * Insert > Date and time: show or hide the date, through the date placeholder
 * (`p:ph type="dt"`) of each slide's layout or master. With `text`, every slide that shows the
 * date shows `text`: a `datetime1` field, which a presentation application can update when it
 * opens the file, or fixed text with `fixed: true`. Without `text`, a slide keeps its date, and
 * a slide without one takes the date that the other slides show, else today's date
 * (month/day/year) as a field; with `fixed: true`, the dates become fixed text. A slide that has
 * a date keeps its box and format. Refused when no target slide's layout or master has a date
 * placeholder, and for blank or multi-line text.
 */
 | ({
    readonly type: 'setDateTime';
    readonly show: boolean;
    readonly text?: string;
    readonly fixed?: boolean;
} & HeaderFooterTargets)
/** Delete the selected slides (`EditorSnapshot.selectedSlides`) as one undo step. */
 | {
    readonly type: 'deleteSlides';
    readonly indices: readonly number[];
}
/** Duplicate the selected slides; the copies follow the last one, in order. */
 | {
    readonly type: 'duplicateSlides';
    readonly indices: readonly number[];
}
/**
 * Move the selected slides as one block, in order, so the block starts at `to`, counted
 * among the slides that do not move. The block joins the section of the slide before it.
 * `section` (a `SlideSection.id`) puts it into that section instead, for a drop below a
 * section header or a step across one in the slide pane: the section must be the
 * section of the slide before the block, of the slide after it, or an empty section between
 * them; otherwise the command is refused. With `section`, a block that stays in place only
 * changes its section.
 */
 | {
    readonly type: 'moveSlides';
    readonly indices: readonly number[];
    readonly to: number;
    readonly section?: string;
}
/**
 * Speaker notes: write `text` as slide `index`'s notes. With `paragraphs` (the same text as
 * formatted runs, as a notes field shows it), each character also takes the bold, italic,
 * underline, and strikethrough it has there, in the same undo step.
 */
 | {
    readonly type: 'setNotes';
    readonly index: number;
    readonly text: string;
    readonly paragraphs?: readonly NotesParagraph[];
}
/**
 * Speaker notes: bold, italic, underline, or strikethrough on the plain-text range
 * `[start, end)` of slide `index`'s notes (offsets as in `EditorSnapshot.notes`), as one undo
 * step. `value` absent toggles: on, unless the whole range already has the format.
 */
 | {
    readonly type: 'formatNotes';
    readonly index: number;
    readonly start: number;
    readonly end: number;
    readonly format: NotesFormat;
    readonly value?: boolean;
}
/**
 * Home > Section > Add Section: a section that starts at slide `index` (the current slide when
 * absent) and takes the rest of the section it splits. `name` defaults to the translated
 * "Untitled Section" (`sections.untitled`). In a deck without sections, the slides before it go
 * into a first section named `defaultSectionName`, by default "Default Section" (`sections.default`).
 */
 | {
    readonly type: 'addSection';
    readonly name?: string;
    readonly index?: number;
    readonly defaultSectionName?: string;
}
/** Home > Section > Remove All Sections: the slides stay, the section list goes. */
 | {
    readonly type: 'removeAllSections';
}
/** Home > Section > Rename Section. */
 | {
    readonly type: 'renameSection';
    readonly sectionId: string;
    readonly name: string;
}
/**
 * Remove Section: its slides join the section before it (after it, for the first). With
 * `withSlides`, Remove Section & Slides deletes them. The last section removes the list.
 * `sectionId` absent: the section of the current slide.
 */
 | {
    readonly type: 'removeSection';
    readonly sectionId?: string;
    readonly withSlides?: boolean;
}
/** Move Section Up (`-1`) or Down (`1`), with its slides. */
 | {
    readonly type: 'moveSection';
    readonly sectionId: string;
    readonly direction: -1 | 1;
}
/**
 * Home > Layout: put the slides on a layout of the deck (`SlideLayoutSummary.id`) as one undo
 * step. Placeholders re-map by type and index, and their content is kept.
 * `indices` absent: the selected slides (`EditorSnapshot.selectedSlides`).
 */
 | {
    readonly type: 'applyLayout';
    readonly layoutId: string;
    readonly indices?: readonly number[];
}
/**
 * Home > Reset: re-apply each slide's layout. Text placeholders go back to the layout's
 * position, size, and formatting, and deleted placeholders come back; their text stays.
 * Pictures, tables, and charts in placeholders keep their own box. `indices` absent: the
 * selected slides.
 */
 | {
    readonly type: 'resetSlides';
    readonly indices?: readonly number[];
}
/**
 * Slide Show > Hide Slide: hide the slides (`p:sld/@show="0"`) or show them again. `indices`
 * absent: the selected slides. `hidden` absent: the toggle, which hides them unless every one
 * of them is hidden already.
 */
 | {
    readonly type: 'setSlidesHidden';
    readonly indices?: readonly number[];
    readonly hidden?: boolean;
}
/** View > Smart guides: drags snap to and show alignment guides. A view setting, not an edit. */
 | {
    readonly type: 'toggleSmartGuides';
}
/**
 * Set the table border pen (`snapshot.tableBorderPen`) that the Borders menu draws with. A
 * setting of this editor, not an edit: no undo step, never saved.
 */
 | {
    readonly type: 'setTableBorderPen';
    readonly pen: TableBorderPen;
}
/** View > Normal or Slide Sorter. A view setting, not an edit: no undo step, never saved. */
 | {
    readonly type: 'setPresentationView';
    readonly view: PresentationView;
}
/**
 * Collapse or expand sections in the slide pane and the slide sorter (Collapse All, Expand All
 * when `sectionIds` is absent). A view setting, not an edit: no undo step, never saved.
 */
 | {
    readonly type: 'setSectionsCollapsed';
    readonly collapsed: boolean;
    readonly sectionIds?: readonly string[];
}
/**
 * Replace one find match with `replacement`. The new text takes the formatting of the first
 * replaced character. Refused when the matched text is no longer there.
 */
 | {
    readonly type: 'replace';
    readonly match: FindMatch;
    readonly replacement: string;
}
/** Replace every match of `query` in the deck (slides, tables, notes) as one undo step. */
 | {
    readonly type: 'replaceAll';
    readonly query: string;
    readonly replacement: string;
    readonly options?: FindOptions;
} | {
    readonly type: 'setTransform';
    readonly nodeId: string;
    readonly x: number;
    readonly y: number;
    readonly cx: number;
    readonly cy: number;
    readonly rot: number;
} | {
    readonly type: 'nudge';
    readonly dx: number;
    readonly dy: number;
}
/** Shape fill: a color choice, or null for no fill. */
 | {
    readonly type: 'setShapeFill';
    readonly color: ColorChoice | null;
}
/** Shape fill: a linear or radial gradient. */
 | {
    readonly type: 'setShapeGradient';
    readonly gradient: GradientFill;
}
/** Outline color: a color choice, or null for no outline. */
 | {
    readonly type: 'setLineColor';
    readonly color: ColorChoice | null;
}
/** Outline width in points. */
 | {
    readonly type: 'setLineWidth';
    readonly points: number;
} | {
    readonly type: 'setLineDash';
    readonly dash: LineDash;
}
/**
 * Link the selected text to a URL (`http`, `https`, `mailto`, `tel`, `ftp`), or to a slide:
 * `#slide-3`, `#next-slide`, `#previous-slide`, `#first-slide`, `#last-slide`. null unlinks.
 */
 | {
    readonly type: 'setLink';
    readonly url: string | null;
}
/** Remove character formatting from the selected text; links stay. */
 | {
    readonly type: 'clearFormatting';
}
/** Vertical alignment of text in its shape (`a:bodyPr/@anchor`). */
 | {
    readonly type: 'setVerticalAlign';
    readonly anchor: VerticalAlign;
}
/** Arrowheads of a line: `head` at its start, `tail` at its end. Absent keeps the current end. */
 | {
    readonly type: 'setLineEnds';
    readonly head?: LineEndType;
    readonly tail?: LineEndType;
}
/**
 * The slide background: a color, a gradient, or a picture; null removes the slide's own
 * background so the layout's shows. `allSlides` applies it to every slide.
 */
 | {
    readonly type: 'setSlideBackground';
    readonly background: SlideBackground | null;
    readonly allSlides?: boolean;
}
/** Slide size in EMU, 1 to 56 in a side; `content: 'scale'` (default) fits the content. */
 | {
    readonly type: 'setSlideSize';
    readonly width: number;
    readonly height: number;
    readonly content?: 'scale' | 'keep';
}
/** Adjust values of one preset shape by guide name, in guide units (see `a:gd`). */
 | {
    readonly type: 'setAdjustments';
    readonly values: Readonly<Record<string, number>>;
}
/** Insert a line, an arrow, or an elbow or curved connector. */
 | {
    readonly type: 'insertLine';
    readonly kind: LineKind;
}
/** Text fitting: none, shrink text on overflow, or resize the shape to fit its text. */
 | {
    readonly type: 'setAutofit';
    readonly mode: TextFitting;
}
/** The selected shapes' text warp, with adjust values by guide name; null removes it. */
 | {
    readonly type: 'setTextWarp';
    readonly preset: TextWarpPreset | null;
    readonly adjust?: Readonly<Record<string, number>>;
} | {
    readonly type: 'setTransforms';
    readonly items: readonly TransformItem[];
} | {
    readonly type: 'group';
} | {
    readonly type: 'ungroup';
} | {
    readonly type: 'paste';
    readonly payload: ClipboardPayload;
}
/**
 * The Format Painter button. A press copies the formatting of the selection and arms the
 * painter for one paint; a second press within the double-click time keeps it on until
 * Escape (`sticky` does that at once); a press while it is on turns it off.
 */
 | {
    readonly type: 'toggleFormatPainter';
    readonly sticky?: boolean;
}
/** Copy the formatting of the selection without arming the painter (Ctrl/Cmd+Shift+C). */
 | {
    readonly type: 'copyFormat';
}
/** Apply the copied formatting to the selection as one undo step (Ctrl/Cmd+Shift+V). */
 | {
    readonly type: 'pasteFormat';
} | TextFormatCommand | PictureCommand | ChartCommand | EquationCommand | DiagramCommand | FillCommand | AnimationCommand
/**
 * Shape Effects: set or remove one effect of the selected shapes, connectors, and pictures.
 * A shape whose effects come from its theme style (`a:effectRef`) gets that style's effects
 * written into it first, so its other effects stay.
 */
 | {
    readonly type: 'setShapeEffect';
    readonly effect: ShapeEffectChoice;
}
/**
 * Shape Styles: apply a theme style of the Shape Styles gallery to the selected shapes. It
 * writes `p:style` and removes the shape's own fill, outline, and effects.
 */
 | {
    readonly type: 'setShapeStyle';
    readonly style: ShapeStyleChoice;
}
/**
 * Distribute the selected elements so the gaps between them are equal. One element centers
 * on the slide; two are refused; three or more keep the outer two in place.
 */
 | {
    readonly type: 'distributeObjects';
    readonly axis: ObjectAxis;
}
/** Flip each selected element about its own center (`a:xfrm/@flipH`, `@flipV`). */
 | {
    readonly type: 'flipObjects';
    readonly axis: ObjectAxis;
}
/** Turn each selected element by `degrees` about its center; 90 is Rotate Right 90°. */
 | {
    readonly type: 'rotateObjects';
    readonly degrees: number;
}
/** Lock or unlock the aspect ratio of the selected elements (`noChangeAspect`). */
 | {
    readonly type: 'setLockAspectRatio';
    readonly lock: boolean;
}
/** Selection pane: show or hide elements of the current slide (`p:cNvPr/@hidden`). */
 | {
    readonly type: 'setShapesVisible';
    readonly nodeIds: readonly string[];
    readonly visible: boolean;
}
/** Selection pane: rename an element of the current slide (`p:cNvPr/@name`). */
 | {
    readonly type: 'renameShape';
    readonly nodeId: string;
    readonly name: string;
} | TableCommand;

EditorCommandTypetypeSource ↗

The command type names.

type EditorCommandType = EditorCommand['type'];

EditorExecOptionstypeSource ↗

Options for one command.

type EditorExecOptions = HistoryGroupOptions;

EditorFontErrorCodetypeSource ↗

Why a font was not admitted.

Distinguished rather than collapsed because the responses differ: overLimit and malformed are the caller's own bytes, while forbidden and hashMismatch mean the source was not what it claimed and the load should not be retried. wasmUnavailable alone is a HOST fault — the shaper's WASM never loaded, diagnostic carries the remedy — surface it as a setup error.

type EditorFontErrorCode = 'initializationFailed' | 'wasmUnavailable' | 'missing' | 'forbidden' | 'overLimit' | 'malformed' | 'hashMismatch' | 'metadataMismatch' | 'fontFaceLoadFailed' | 'unsupportedFaceIndex' | 'missingFont' | 'hashInvalid' | 'fontMismatch' | 'unsupportedFace' | 'loadFailed';

EditorModetypeSource ↗

The editing mode, matching the toolbar's mode pill.

type EditorMode = 'edit' | 'view';

EditorSelectiontypeSource ↗

What is selected.

type EditorSelection = {
    readonly kind: 'none';
} | {
    readonly kind: 'shapes';
    readonly nodeIds: readonly string[];
    readonly group?: string;
} | {
    readonly kind: 'text';
    readonly nodeId: string;
    readonly anchor: TextPoint;
    readonly focus: TextPoint;
    readonly cell?: TableCellAddress;
    readonly diagramNode?: string;
} | {
    readonly kind: 'cells';
    readonly nodeId: string;
    readonly anchor: TableCellAddress;
    readonly focus: TableCellAddress;
};

EquationCommandtypeSource ↗

The equation commands. An equation's math is written from a linear form, a short text syntax: a/b is a fraction, x^2 and x_i are scripts, \sqrt(x) is a square root, \sum_(i=1)^n is a sum, and \alpha is a Greek letter. The equations guide lists the whole syntax.

type EquationCommand = 
/**
 * Insert > Equation: a new text box centered on the slide, with the equation of `linear`.
 * `font` names the font of its math runs; default `Cambria Math`. The text box is selected.
 */
{
    readonly type: 'insertEquation';
    readonly linear: string;
    readonly font?: string;
}
/**
 * Replace the math of an equation (`SelectedEquationState.nodeId`) with the equation of
 * `linear`. The equation keeps its alignment and the font, size, and color of its first run.
 */
 | {
    readonly type: 'setEquation';
    readonly nodeId: string;
    readonly linear: string;
};

FillCommandtypeSource ↗

The fill commands of shapes beyond a color and a gradient.

type FillCommand = 
/** Shape fill: a preset pattern. */
{
    readonly type: 'setShapePattern';
    readonly pattern: PatternFill;
}
/**
 * Shape fill: a PNG, JPEG, or GIF picture, stretched over the shape, or tiled at its own
 * size when `tile` is true. The type comes from the bytes; other bytes are refused.
 */
 | {
    readonly type: 'setShapePicture';
    readonly bytes: Uint8Array;
    readonly mime?: string;
    readonly tile?: boolean;
};

FormatPainterModetypeSource ↗

The format painter: off, armed for one paint (once), or on until Escape or a second press (sticky).

type FormatPainterMode = 'off' | 'once' | 'sticky';

ImageCroptypeSource ↗

A picture crop. rect crops each edge in percent: the image stays in place and the frame changes, as a crop handle does; with keepFrame, the frame stays and the image moves in it. fill and fit keep the frame and crop the image to cover it or to show all of it; aspect crops the image to a width-to-height ratio.

type ImageCrop = ({
    readonly kind: 'rect';
    readonly keepFrame?: boolean;
} & ImageCropPercent) | {
    readonly kind: 'fill';
} | {
    readonly kind: 'fit';
} | {
    readonly kind: 'aspect';
    readonly width: number;
    readonly height: number;
};

ImageRecolortypeSource ↗

The Recolor presets of the Color gallery. accentNDark and accentNLight are the dark and light variations of theme accent N (a:duotone).

type ImageRecolor = 'none' | 'grayscale' | 'sepia' | 'blackWhite25' | 'blackWhite50' | 'blackWhite75' | `accent${1 | 2 | 3 | 4 | 5 | 6}${'Dark' | 'Light'}`;

ImageStyleIdtypeSource ↗

The picture styles the gallery offers, with the gallery's names in camel case.

type ImageStyleId = 'simpleFrameWhite' | 'simpleFrameBlack' | 'softEdgeRectangle' | 'softEdgeOval' | 'reflectedRoundedRectangle';

LineDashtypeSource ↗

Outline dash presets offered by the chrome (a:prstDash values).

type LineDash = 'solid' | 'sysDot' | 'sysDash' | 'dash' | 'dashDot' | 'lgDash' | 'lgDashDot';

LineEndTypetypeSource ↗

Line end (arrowhead) types (a:headEnd/@type, a:tailEnd/@type).

type LineEndType = 'none' | 'triangle' | 'arrow' | 'stealth' | 'oval' | 'diamond';

LineKindtypeSource ↗

Lines the chrome inserts.

type LineKind = 'line' | 'arrow' | 'elbow' | 'curved';

NotesFormattypeSource ↗

Character formats the speaker notes pane sets.

type NotesFormat = 'bold' | 'italic' | 'underline' | 'strike';

ObjectAligntypeSource ↗

Object alignment targets.

type ObjectAlign = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';

ObjectAxistypeSource ↗

The axis of a flip or a distribute: horizontal acts along x.

type ObjectAxis = 'horizontal' | 'vertical';

OrderMovetypeSource ↗

Z-order moves.

type OrderMove = 'forward' | 'backward' | 'front' | 'back';

ParagraphAlignmenttypeSource ↗

Paragraph alignment as the Paragraph dialog names it (algn: l, ctr, r, just, dist).

type ParagraphAlignment = 'left' | 'center' | 'right' | 'justify' | 'distributed';

PatternPresettypeSource ↗

The 54 preset patterns (ST_PresetPatternVal, ECMA-376 Part 1, 20.1.10.51).

type PatternPreset = 'pct5' | 'pct10' | 'pct20' | 'pct25' | 'pct30' | 'pct40' | 'pct50' | 'pct60' | 'pct70' | 'pct75' | 'pct80' | 'pct90' | 'horz' | 'vert' | 'ltHorz' | 'ltVert' | 'dkHorz' | 'dkVert' | 'narHorz' | 'narVert' | 'dashHorz' | 'dashVert' | 'cross' | 'dnDiag' | 'upDiag' | 'ltDnDiag' | 'ltUpDiag' | 'dkDnDiag' | 'dkUpDiag' | 'wdDnDiag' | 'wdUpDiag' | 'dashDnDiag' | 'dashUpDiag' | 'diagCross' | 'smCheck' | 'lgCheck' | 'smGrid' | 'lgGrid' | 'dotGrid' | 'smConfetti' | 'lgConfetti' | 'horzBrick' | 'diagBrick' | 'solidDmnd' | 'openDmnd' | 'dotDmnd' | 'plaid' | 'sphere' | 'weave' | 'divot' | 'shingle' | 'wave' | 'trellis' | 'zigZag';

PictureCommandtypeSource ↗

The picture commands (picture-commands.ts): crop, crop to shape, crop mode, Change Picture, Reset Picture, Corrections and Color, styles, Format Picture, and alt text.

type PictureCommand = 
/**
 * Crop the selected picture (`a:srcRect`): to a crop rectangle, where the image stays in place
 * on the slide and the frame changes; to fill or fit its frame; or to an aspect ratio.
 */
{
    readonly type: 'cropImage';
    readonly crop: ImageCrop;
}
/** Crop the selected pictures to a preset shape (`a:prstGeom`); `rect` crops back to a rectangle. */
 | {
    readonly type: 'cropToShape';
    readonly preset: string;
}
/**
 * The Crop button: turn crop mode on for the selected picture, or off. In crop mode the crop
 * handles show; Escape, a second press, or another selection ends it.
 */
 | {
    readonly type: 'toggleCrop';
}
/**
 * Change Picture: replace the selected picture's image with an image file. The new image fits
 * in the old frame; the crop resets, and the border, effects, and adjustments stay. `width` and
 * `height` are the stored pixel size; without them, the engine reads it from the image header.
 * A JPEG's EXIF orientation does not count: the stored pixels do.
 */
 | {
    readonly type: 'replaceImage';
    readonly bytes: Uint8Array;
    readonly mime: string;
    readonly width?: number;
    readonly height?: number;
}
/**
 * Reset Picture: remove the adjustments, the border, the effects, and the crop to a shape.
 * `size` also removes the crop and gives the picture its own size (Reset Picture & Size).
 */
 | {
    readonly type: 'resetImage';
    readonly size?: boolean;
}
/** Corrections, color, and transparency of the selected pictures. Absent fields stay. */
 | {
    readonly type: 'setImageAdjustments';
    readonly adjustments: ImageAdjustments;
}
/** A picture style of the Picture Styles gallery: border, effects, and shape. */
 | {
    readonly type: 'setImageStyle';
    readonly style: ImageStyleId;
}
/**
 * Format Picture: the size, rotation, and crop of the selected picture as one undo step, with
 * the fields on the command, after DOCX Editor's `setImageProperties`. It takes `widthEmu`,
 * `heightEmu`, and `crop` as DOCX Editor does, plus `rotationDegrees`; absent fields stay, and
 * any other field is refused. DOCX Editor's other fields live elsewhere: alt text in
 * `setAltText` (every object), links in `setLink`, the natural size in `resetImage` with
 * `size`, the border in the Shape line commands; it has no target check, as the dialog closes
 * when its picture changes. DOCX Editor's wrap and position fields have no slide equivalent.
 */
 | ({
    readonly type: 'setImageProperties';
} & ImageProperties)
/**
 * Alt text of the selected element (`p:cNvPr/@descr` and `@title`). `decorative` marks it as
 * decorative, as the Alt Text pane does; a decorative element keeps no description,
 * and a description for one is refused unless `decorative` is false. An absent field keeps the
 * element's own; an empty description or title removes it.
 */
 | {
    readonly type: 'setAltText';
    readonly description?: string;
    readonly title?: string;
    readonly decorative?: boolean;
};

PresentationViewtypeSource ↗

How the editor shows the deck: normal (the slide with the rail and notes), slideSorter (every slide as a thumbnail, by section), or slideMaster (the slide masters and layouts, edited on the canvas), as the View tab names them (ppViewNormal, ppViewSlideSorter, ppViewSlideMaster).

type PresentationView = 'normal' | 'slideSorter' | 'slideMaster';

ReflectionPresettypeSource ↗

The presets of the Reflection gallery: size, and the gap to the shape.

type ReflectionPreset = 'tightTouching' | 'halfTouching' | 'fullTouching' | 'tight4pt' | 'half4pt' | 'full4pt' | 'tight8pt' | 'half8pt' | 'full8pt';

ReviewPaneOpeningtypeSource ↗

What a press on a comment marker does besides picking the thread. auto: it also asks for the **Comments** tab of the side panel (requestPane). manual: it only picks the thread, and the host opens its own comments view.

type ReviewPaneOpening = 'auto' | 'manual';

RotateChoicetypeSource ↗

An arrange.rotate value: the 90° turns, then the flips.

type RotateChoice = 'right90' | 'left90' | 'flipVertical' | 'flipHorizontal';

Rotation3DPresettypeSource ↗

The presets of the 3-D Rotation gallery: camera presets of ST_PresetCameraType (ECMA-376 Part 1, 20.1.10.47) with parallel projection.

type Rotation3DPreset = 'isometricLeftDown' | 'isometricRightUp' | 'isometricTopUp' | 'isometricOffAxis1Left' | 'isometricOffAxis1Right' | 'obliqueTopLeft' | 'obliqueTopRight' | 'obliqueBottomLeft' | 'obliqueBottomRight';

ShadowPresettypeSource ↗

The presets of the Shadow gallery: the nine Outer shadows ("Offset: Bottom Right") and the nine Inner shadows ("Inside: Top Left").

type ShadowPreset = 'outerBottomRight' | 'outerBottom' | 'outerBottomLeft' | 'outerRight' | 'outerCenter' | 'outerLeft' | 'outerTopRight' | 'outerTop' | 'outerTopLeft' | 'innerTopLeft' | 'innerTop' | 'innerTopRight' | 'innerLeft' | 'innerCenter' | 'innerRight' | 'innerBottomLeft' | 'innerBottom' | 'innerBottomRight';

ShapeEffectChoicetypeSource ↗

One effect to set; a null preset or size removes the effect.

type ShapeEffectChoice = {
    readonly kind: 'shadow';
    readonly preset: ShadowPreset | null;
} | {
    readonly kind: 'reflection';
    readonly preset: ReflectionPreset | null;
} | {
    readonly kind: 'glow';
    readonly size: number | null;
    readonly color?: ColorChoice;
}
/** Soft edge size in points (the gallery offers 1, 2.5, 5, 10, 25, and 50). */
 | {
    readonly kind: 'softEdge';
    readonly size: number | null;
}
/** Blur radius in points (`a:blur`). No gallery offers it. */
 | {
    readonly kind: 'blur';
    readonly size: number | null;
}
/** A top bevel (`a:sp3d/a:bevelT`), with a front camera when the shape has no scene. */
 | {
    readonly kind: 'bevel';
    readonly preset: BevelPreset | null;
}
/** A camera preset (`a:scene3d/a:camera`); null turns the camera back to the front. */
 | {
    readonly kind: 'rotation3d';
    readonly preset: Rotation3DPreset | null;
};

ShapeEffectsValuetypeSource ↗

A shape.effects option value: an effect and its choice (shadow.outerTop, glow.8.accent2, softEdge.none). A glow without a color keeps the shape's glow color. Sizes are points above 0; the command refuses others. The slot's state value lists the current choice of each effect, separated by spaces: test an option with chromeOptionChecked.

type ShapeEffectsValue = `shadow.${ShadowPreset | 'none'}` | `reflection.${ReflectionPreset | 'none'}` | `glow.${number | 'none'}` | `glow.${number}.${Exclude<ShapeStyleColor, 'dk1'>}` | `softEdge.${number | 'none'}` | `bevel.${BevelPreset | 'none'}` | `rotation3d.${Rotation3DPreset | 'none'}`;

ShapeStyleColortypeSource ↗

The columns of the Shape Styles gallery: Dark 1, then Accent 1 to 6 (theme color names).

type ShapeStyleColor = 'dk1' | 'accent1' | 'accent2' | 'accent3' | 'accent4' | 'accent5' | 'accent6';

ShapeStyleRowtypeSource ↗

The rows of the Shape Styles gallery (theme styles), top to bottom: Colored Outline, Colored Fill, Light 1 Outline Colored Fill, Subtle Effect, Moderate Effect, Intense Effect.

type ShapeStyleRow = 'coloredOutline' | 'coloredFill' | 'lightOutline' | 'subtleEffect' | 'moderateEffect' | 'intenseEffect';

ShapeStyleValuetypeSource ↗

A shape.styles value: a gallery cell as row.color (intenseEffect.accent2).

type ShapeStyleValue = `${ShapeStyleRow}.${ShapeStyleColor}`;

SlideBackgroundtypeSource ↗

A slide background the chrome sets.

type SlideBackground = {
    readonly kind: 'solid';
    readonly color: ColorChoice;
} | {
    readonly kind: 'gradient';
    readonly gradient: GradientFill;
} | {
    readonly kind: 'pattern';
    readonly pattern: PatternFill;
} | {
    readonly kind: 'picture';
    readonly bytes: Uint8Array;
    readonly mime: string;
    readonly tile?: boolean;
};

SlideLayoutKindtypeSource ↗

The kind of a slide layout, with the file's own values: ST_SlideLayoutType (ECMA-376 Part 1, §19.7.15). cust is a custom layout, and also the value for a file that names none or an unknown kind. The Office.js SlideLayoutType enum names the same idea with other values ("TitleOnly" for titleOnly); the automation API keeps that name for its own type.

type SlideLayoutKind = 'title' | 'tx' | 'twoColTx' | 'tbl' | 'txAndChart' | 'chartAndTx' | 'dgm' | 'chart' | 'txAndClipArt' | 'clipArtAndTx' | 'titleOnly' | 'blank' | 'txAndObj' | 'objAndTx' | 'objOnly' | 'obj' | 'txAndMedia' | 'mediaAndTx' | 'objOverTx' | 'txOverObj' | 'txAndTwoObj' | 'twoObjAndTx' | 'twoObjOverTx' | 'fourObj' | 'vertTx' | 'clipArtAndVertTx' | 'vertTitleAndTx' | 'vertTitleAndTxOverChart' | 'twoObj' | 'objAndTwoObj' | 'twoObjAndObj' | 'cust' | 'secHead' | 'twoTxTwoObj' | 'objTx' | 'picTx';

SlideSelectModetypeSource ↗

How a click in the slide rail changes the slide selection.

type SlideSelectMode = 'replace' | 'toggle' | 'range';

StrikeStyletypeSource ↗

Strikethrough: none, single, or double (ST_TextStrikeType).

type StrikeStyle = 'none' | 'single' | 'double';

TableBorderEdgeTargettypeSource ↗

The edges a border is set on: every target but none, as DOCX Editor's type.

type TableBorderEdgeTarget = Exclude<TableBorderTarget, 'none'>;

TableBorderTargettypeSource ↗

Which cell edges a border command sets, as DOCX Editor's TableBorderTarget.

type TableBorderTarget = 'all' | 'outside' | 'inside' | 'none' | 'top' | 'bottom' | 'left' | 'right';

TableCommandtypeSource ↗

Table commands (table-commands.ts). Each acts on the table of the selection: a caret in a cell, a cell range, or the selected table frame. The structure commands have DOCX Editor's names; three differ (the style options, the shared Align buttons, and No Border).

type TableCommand = 
/** Insert > Table: a `rows` × `cols` table with the theme's default table style. */
{
    readonly type: 'insertTable';
    readonly rows: number;
    readonly cols: number;
}
/** Insert a row above or below the selected rows. */
 | {
    readonly type: 'insertRow';
    readonly where: 'above' | 'below';
}
/** Insert a column left or right of the selected columns. */
 | {
    readonly type: 'insertColumn';
    readonly where: 'left' | 'right';
} | {
    readonly type: 'deleteRow';
} | {
    readonly type: 'deleteColumn';
} | {
    readonly type: 'deleteTable';
}
/** Select the whole table, or the rows or columns of the selected cells. Not an edit. */
 | {
    readonly type: 'selectTableRegion';
    readonly region: 'table' | 'row' | 'column';
}
/** Merge the selected cell range into one cell; the text of every cell is kept. */
 | {
    readonly type: 'mergeCells';
}
/** Split the selected cell into `rows` × `cols` cells. */
 | {
    readonly type: 'splitCell';
    readonly rows: number;
    readonly cols: number;
}
/** Cell shading: a color choice, or null for No Fill (`a:noFill`, over the style's fill). */
 | {
    readonly type: 'setCellFill';
    readonly color: ColorChoice | null;
}
/** Borders of the selected cells, drawn with `spec`; `scope: 'none'` removes them. */
 | {
    readonly type: 'setTableBorders';
    readonly scope: 'none';
} | {
    readonly type: 'setTableBorders';
    readonly scope: TableBorderEdgeTarget;
    readonly spec: TableBorderSpec;
}
/** The table style (`a:tableStyleId`), by `styleId`. */
 | {
    readonly type: 'setTableStyle';
    readonly styleId: string;
}
/** Turn one table style option (`a:tblPr` flag) on or off. */
 | {
    readonly type: 'toggleTableStyleOption';
    readonly option: TableStyleOption;
}
/** Cell margins in EMU; an absent side keeps its value. */
 | {
    readonly type: 'setCellMargins';
    readonly margins: {
        readonly left?: number;
        readonly right?: number;
        readonly top?: number;
        readonly bottom?: number;
    };
}
/** The height of the selected rows in EMU (`a:tr/@h`, a minimum). */
 | {
    readonly type: 'setRowHeight';
    readonly height: number;
}
/** The width of the selected columns in EMU (`a:gridCol/@w`). */
 | {
    readonly type: 'setColumnWidth';
    readonly width: number;
}
/**
 * Fill cells with plain text from the top-left cell of the selection (a paste of copied
 * cells): one array for each row, one string for each cell. Each written cell keeps the format
 * of its first run. Text past the table's edge adds rows at the bottom and columns at the end of the grid (the right, or the left in a right-to-left table)
 * (new columns share the table's width), up to the table limits; a position inside a merged
 * cell is skipped.
 */
 | {
    readonly type: 'pasteCells';
    readonly texts: readonly (readonly string[])[];
}
/** Give the selected rows (or every row) the same height. */
 | {
    readonly type: 'distributeRows';
}
/** Give the selected columns (or every column) the same width. */
 | {
    readonly type: 'distributeColumns';
}
/**
 * Set every column width and row height of the selected table, in EMU (a grid line drag).
 * Run the steps of one drag with one `historyGroup` (`exec` options) for one undo step.
 */
 | {
    readonly type: 'setTableGrid';
    readonly columns?: readonly number[];
    readonly rows?: readonly number[];
};

TableStyleOptiontypeSource ↗

Table style options, the a:tblPr flags: Header Row, Total Row, Banded Rows, First Column, Last Column, Banded Columns.

type TableStyleOption = 'firstRow' | 'lastRow' | 'bandRow' | 'firstCol' | 'lastCol' | 'bandCol';

TextAligntypeSource ↗

Paragraph alignment values the chrome can set.

type TextAlign = 'l' | 'ctr' | 'r' | 'just';

TextCasetypeSource ↗

Change Case choices: "Sentence case.", "lowercase", "UPPERCASE", "Capitalize Each Word", and "tOGGLE cASE".

type TextCase = 'sentence' | 'lower' | 'upper' | 'capitalize' | 'toggle';

TextEffectsValuetypeSource ↗

A shape.textEffects option value: transform. and a text warp, or transform.none to remove the warp.

type TextEffectsValue = `transform.${Exclude<TextWarpPreset, 'textNoShape'> | 'none'}`;

TextFittingtypeSource ↗

Text fitting modes (a:noAutofit, a:normAutofit, a:spAutoFit).

type TextFitting = 'none' | 'shrink' | 'shape';

TextFormatCommandtypeSource ↗

The text format commands of EditorCommand: the Paragraph, Font, and Bullets and Numbering dialogs, superscript and subscript, Change Case, character spacing, Text Direction, and Columns. Each acts on the selected text, or on all text of the selected shapes.

type TextFormatCommand = 
/**
 * Format > Paragraph: alignment, indents, spacing before and after, and line spacing on every
 * selected paragraph, as one undo step. DOCX Editor's command name; the fields follow its
 * `ParagraphFormatCommand`, in PresentationML units (EMU indents, spacing in points or lines).
 */
({
    readonly type: 'setParagraphFormat';
} & ParagraphFormatCommand)
/** Superscript on or off: the button writes `baseline` 30 % up. */
 | {
    readonly type: 'toggleSuperscript';
}
/** Subscript on or off: the button writes `baseline` 25 % down. */
 | {
    readonly type: 'toggleSubscript';
}
/** Home > Change Case: rewrite the letters of the selected text. Formatting stays. */
 | {
    readonly type: 'changeCase';
    readonly case: TextCase;
}
/** Home > Character Spacing: points added after each character (`spc`); 0 is Normal. */
 | {
    readonly type: 'setCharacterSpacing';
    readonly points: number;
}
/** Format > Font: the fields of the Font dialog, as one undo step. */
 | ({
    readonly type: 'setFontFormat';
} & FontFormatCommand)
/**
 * Home > Text Direction (`a:bodyPr/@vert`) of the selected shapes. The type leaves out
 * `mongolianVertical` and `wordArtVerticalRtl`, which layout does not draw correctly;
 * the engine refuses them too.
 */
 | {
    readonly type: 'setTextDirection';
    readonly direction: Exclude<TextOrientation, 'mongolianVertical' | 'wordArtVerticalRtl'>;
}
/**
 * Home > Columns: the number of text columns (1 to 16, `numCol`) of the selected shapes, and
 * the gap between them in EMU (`spcCol`, 0 to 51206400). An absent `gapEmu` keeps the gap.
 */
 | {
    readonly type: 'setColumns';
    readonly count: number;
    readonly gapEmu?: number;
}
/**
 * Home > Bullets or Numbering (a gallery item), or Format > Bullets and Numbering: the bullet
 * format of the selected paragraphs (Office.js `ParagraphFormat.bulletFormat`).
 * `null` is the gallery's None: the list turns off.
 */
 | {
    readonly type: 'setBulletFormat';
    readonly format: BulletFormat | null;
}
/**
 * Paste formatted text: DrawingML paragraphs (`a:p`, as `ClipboardNode`s) replace the selected
 * text, or, with no text selected, go in a new text box in the middle of the slide. The
 * paragraphs are checked as untrusted input: runs, breaks, and their formatting are kept, and
 * links, pictures, and relationship references are left out. A field becomes plain text.
 */
 | {
    readonly type: 'pasteText';
    readonly paragraphs: readonly ClipboardNode[];
};

TextOrientationtypeSource ↗

The orientation of a shape's text (Home Text Direction), in the words of Office.js's the Office.js ShapeTextOrientation enum:horizontal, rotated 90° (vertical, file vert) or 270° (vertical270), stacked letters (wordArtVertical), upright East Asian text (eastAsianVertical, file eaVert), and the two the editor reads but does not set (mongolianVertical, wordArtVerticalRtl). Not DOCX Editor's TextDirection, which is bidi.

type TextOrientation = 'horizontal' | 'vertical' | 'vertical270' | 'wordArtVertical' | 'eastAsianVertical' | 'mongolianVertical' | 'wordArtVerticalRtl';

TextWarpPresettypeSource ↗

A preset text warp (a:prstTxWarp/@prst, ST_TextShapeType, ECMA-376 Part 1, 20.1.10.76). textNoShape draws the text flat.

type TextWarpPreset = 'textNoShape' | 'textPlain' | 'textStop' | 'textTriangle' | 'textTriangleInverted' | 'textChevron' | 'textChevronInverted' | 'textRingInside' | 'textRingOutside' | 'textArchUp' | 'textArchDown' | 'textCircle' | 'textButton' | 'textArchUpPour' | 'textArchDownPour' | 'textCirclePour' | 'textButtonPour' | 'textCurveUp' | 'textCurveDown' | 'textCanUp' | 'textCanDown' | 'textWave1' | 'textWave2' | 'textDoubleWave1' | 'textWave4' | 'textInflate' | 'textDeflate' | 'textInflateBottom' | 'textDeflateBottom' | 'textInflateTop' | 'textDeflateTop' | 'textDeflateInflate' | 'textDeflateInflateDeflate' | 'textFadeRight' | 'textFadeLeft' | 'textFadeUp' | 'textFadeDown' | 'textSlantUp' | 'textSlantDown' | 'textCascadeUp' | 'textCascadeDown';

ThemeColorSlottypeSource ↗

A theme color as the color menus name it: the color map's names, so bg1 is the color the slide's p:clrMap maps to Background 1.

type ThemeColorSlot = 'bg1' | 'tx1' | 'bg2' | 'tx2' | 'accent1' | 'accent2' | 'accent3' | 'accent4' | 'accent5' | 'accent6';

TransitionKindtypeSource ↗

The kinds of transition that setTransition writes.

type TransitionKind = 'fade' | 'push' | 'wipe' | 'split' | 'cut';

UnderlineStyletypeSource ↗

Underline styles: ST_TextUnderlineType in words, as Office.js names them (single is sng, double is dbl, wavyDouble is wavyDbl).

type UnderlineStyle = 'none' | 'words' | 'single' | 'double' | 'heavy' | 'dotted' | 'dottedHeavy' | 'dash' | 'dashHeavy' | 'dashLong' | 'dashLongHeavy' | 'dotDash' | 'dotDashHeavy' | 'dotDotDash' | 'dotDotDashHeavy' | 'wavy' | 'wavyHeavy' | 'wavyDouble';

VerticalAligntypeSource ↗

Vertical text alignment: top, middle, bottom.

type VerticalAlign = 't' | 'ctr' | 'b';