API Reference: Types

All types are exported from the main pptx-craft package.

import type { TextOptions, Color, Fill, ChartType /* ... */ } from 'pptx-craft';

Measurements & Placement

Inches

type Inches = number;

All position and size values use inches as the unit.

Emu

type Emu = number;

English Metric Units (914,400 EMUs per inch). Used internally for OOXML.

Placement

interface Placement {
  x: Inches;       // horizontal offset from left edge
  y: Inches;       // vertical offset from top edge
  w: Inches;       // width
  h: Inches;       // height
  rotation?: number; // clockwise rotation (0–360°)
}

---

Colors

Color

type Color = string | SrgbColor | SchemeColor | SystemColor | PresetColor | HslColor;

A bare hex string (e.g. 'FF6600') for solid sRGB, or a structured color object.

SrgbColor

interface SrgbColor {
  hex: string;
  transforms?: ColorTransform;
}

SchemeColor

interface SchemeColor {
  scheme: SchemeColorVal;
  transforms?: ColorTransform;
}

SchemeColorVal

type SchemeColorVal =
  | 'dk1' | 'lt1' | 'dk2' | 'lt2'
  | 'accent1' | 'accent2' | 'accent3' | 'accent4' | 'accent5' | 'accent6'
  | 'hlink' | 'folHlink'
  | 'phClr' | 'bg1' | 'bg2' | 'tx1' | 'tx2';

SystemColor

interface SystemColor {
  sys: string;
  lastClr?: string;
  transforms?: ColorTransform;
}

PresetColor

interface PresetColor {
  preset: string;
  transforms?: ColorTransform;
}

HslColor

interface HslColor {
  hue: number;
  sat: number;
  lum: number;
  transforms?: ColorTransform;
}

ColorTransform

Modifiers applied as children of any color element.

interface ColorTransform {
  tint?: number;
  shade?: number;
  lumMod?: number;
  lumOff?: number;
  alpha?: number;
  alphaOff?: number;
  satMod?: number;
  satOff?: number;
  hueMod?: number;
  hueOff?: number;
}

---

Fills

Fill

type Fill = string | GradientFill | PatternFill | PictureFill;

A hex string for solid fill, or an object for gradient / pattern / picture.

GradientFill

interface GradientFill {
  type: GradientDirection;       // 'linear' | 'radial' | 'path'
  stops: GradientStop[];
  angle?: number;                // degrees, for linear gradients
}

GradientStop

interface GradientStop {
  position: number;   // 0–100
  color: Color;
  alpha?: number;     // opacity 0–100 (default 100)
}

GradientDirection

type GradientDirection = 'linear' | 'radial' | 'path';

PatternFill

interface PatternFill {
  pattern: PatternType;
  foreground: Color;
  background: Color;
}

PatternType

DrawingML preset pattern identifiers. Common values: 'pct5', 'pct10', 'pct20', 'pct25', 'pct50', 'horz', 'vert', 'cross', 'dnDiag', 'upDiag', 'diagCross', 'smCheck', 'lgCheck', 'smGrid', 'lgGrid', 'dotGrid', 'plaid', 'sphere', 'weave', 'zigZag', and more.

PictureFill

interface PictureFill {
  path?: string;
  data?: Uint8Array;
  contentType?: string;
  stretch?: boolean;                                    // default true
  tile?: { sx: number; sy: number; tx: number; ty: number };
}

---

Lines

LineProperties

interface LineProperties {
  color?: Color;
  width?: number;          // points
  dash?: LineDash;
  cap?: LineCap;
  join?: LineJoin;
  headEnd?: LineEndProperties;
  tailEnd?: LineEndProperties;
  fill?: Fill;
  opacity?: number;        // 0–100
  compound?: 'sng' | 'dbl' | 'thickThin' | 'thinThick' | 'tri';
  alignment?: 'ctr' | 'in';
  customDash?: Array<{ d: number; sp: number }>;  // EMUs
}

LineDash

type LineDash =
  | 'solid' | 'dash' | 'dashDot' | 'lgDash' | 'lgDashDot'
  | 'lgDashDotDot' | 'sysDash' | 'sysDashDot' | 'sysDashDotDot'
  | 'sysDot' | 'dot';

LineCap

type LineCap = 'flat' | 'round' | 'square';

LineJoin

type LineJoin = 'round' | 'bevel' | 'miter';

LineEndType

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

LineEndSize

type LineEndSize = 'sm' | 'med' | 'lg';

LineEndProperties

interface LineEndProperties {
  type?: LineEndType;
  width?: LineEndSize;
  length?: LineEndSize;
}

---

Effects

EffectProperties

interface EffectProperties {
  shadow?: ShadowEffect;
  glow?: GlowEffect;
  reflection?: ReflectionEffect;
  softEdge?: SoftEdgeEffect;
}

ShadowEffect

interface ShadowEffect {
  type?: 'outer' | 'inner';
  color?: Color;
  alpha?: number;     // 0–100
  blur?: number;      // points
  offset?: number;    // points
  angle?: number;     // degrees
}

GlowEffect

interface GlowEffect {
  color?: Color;
  alpha?: number;    // 0–100
  radius?: number;   // points
}

ReflectionEffect

interface ReflectionEffect {
  blur?: number;         // points
  startAlpha?: number;   // 0–100
  endAlpha?: number;     // 0–100
  distance?: number;     // points
  direction?: number;    // degrees
  fadeDirection?: number; // degrees
}

SoftEdgeEffect

interface SoftEdgeEffect {
  radius?: number;   // points
}

---

3D Properties

Scene3DProperties

interface Scene3DProperties {
  camera?: { preset?: CameraPreset; fov?: number };
  lightRig?: { type?: LightRigType; direction?: LightRigDirection };
}

Shape3DProperties

interface Shape3DProperties {
  bevelTop?: BevelProperties;
  bevelBottom?: BevelProperties;
  extrusionHeight?: number;
  contourWidth?: number;
  extrusionColor?: Color;
  contourColor?: Color;
  material?: PresetMaterial;
}

BevelProperties

interface BevelProperties {
  width?: number;
  height?: number;
  preset?: BevelPreset;
}

BevelPreset

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

PresetMaterial

type PresetMaterial =
  | 'matte' | 'warmMatte' | 'plastic' | 'metal' | 'dkEdge'
  | 'softEdge' | 'flat' | 'softmetal' | 'clear' | 'powder'
  | 'translucentPowder' | 'legacyMatte' | 'legacyPlastic'
  | 'legacyMetal' | 'legacyWireframe';

CameraPreset

Common values: 'orthographicFront', 'isometricTopUp', 'isometricTopDown', 'perspectiveFront', 'perspectiveLeft', 'perspectiveRight', 'perspectiveAbove', 'perspectiveRelaxed'.

Full list includes 40+ presets covering orthographic, isometric, oblique, and perspective projections.

LightRigType

type LightRigType =
  | 'flood' | 'contrasting' | 'morning' | 'sunrise' | 'sunset'
  | 'chilly' | 'freezing' | 'flat' | 'twoPt' | 'glow'
  | 'brightRoom' | 'soft' | 'harsh' | 'balanced' | 'threePt'
  | /* legacy variants */ 'legacyFlat1' | 'legacyNormal1' | 'legacyHarsh1' /* ... */;

LightRigDirection

type LightRigDirection = 't' | 'tl' | 'tr' | 'b' | 'bl' | 'br' | 'l' | 'r';

---

Transform & Hyperlinks

TransformProperties

interface TransformProperties {
  rotation?: number;   // clockwise degrees (0–360)
  flipH?: boolean;     // mirror horizontally
  flipV?: boolean;     // mirror vertically
}

HyperlinkProperties

interface HyperlinkProperties {
  url?: string;       // external URL
  slide?: number;     // internal slide (1-based)
  tooltip?: string;   // hover tooltip
  email?: string;     // generates mailto: link
  file?: string;      // local file path
  action?: string;    // e.g. 'ppaction://hlinkshowjump?jump=nextslide'
}

---

Text

TextOptions

Combined options for addText() — merges Placement, TextRunOptions, ParagraphOptions, TextBodyOptions, plus shape styling.

Option	Type	From
x, y, w, h, rotation	number	Placement
bold, italic, underline, fontSize, fontFace, color, ...	various	TextRunOptions
align, lineSpacing, bullet, numbering, ...	various	ParagraphOptions
verticalAlign, textDirection, wordWrap, autoFit, margin, ...	various	TextBodyOptions
fill	Fill	Text box background
line	LineProperties	Text box border
effects	EffectProperties	Visual effects
transform	TransformProperties	Rotation/flip
scene3d	Scene3DProperties	3D camera + lighting
shape3d	Shape3DProperties	3D extrusion/bevel

TextRunOptions

Character-level formatting (a:rPr).

interface TextRunOptions {
  bold?: boolean;
  italic?: boolean;
  underline?: boolean;
  strikethrough?: boolean | 'single' | 'double';
  fontSize?: number;             // points
  fontFace?: string;
  color?: Color;
  subscript?: boolean;
  superscript?: boolean;
  highlight?: Color;
  letterSpacing?: number;        // points
  baseline?: number;             // percentage
  hyperlink?: HyperlinkProperties;
  outline?: LineProperties;
  shadow?: ShadowEffect;
  caps?: 'none' | 'small' | 'all';
  lang?: string;                 // e.g. 'en-US'
  eastAsianFont?: string;
  complexScriptFont?: string;
  altLang?: string;
}

ParagraphOptions

Paragraph-level formatting (a:pPr).

interface ParagraphOptions {
  align?: 'left' | 'center' | 'right' | 'justify';
  lineSpacing?: number | { value: number; unit: 'pt' | 'pct' };
  spaceBefore?: number | { value: number; unit: 'pt' | 'pct' };
  spaceAfter?: number | { value: number; unit: 'pt' | 'pct' };
  indent?: number;              // points (negative = hanging indent)
  marginLeft?: number;          // points
  level?: number;               // 0–8
  rtl?: boolean;
  bullet?: BulletOptions | boolean;
  numbering?: NumberingOptions;
  tabStops?: TabStop[];
  defaultRunOptions?: TextRunOptions;
}

TextBodyOptions

Text body formatting (a:bodyPr).

interface TextBodyOptions {
  verticalAlign?: 'top' | 'middle' | 'bottom';
  textDirection?: 'horz' | 'vert' | 'vert270' | 'wordArtVert';
  wordWrap?: boolean;
  autoFit?: boolean | 'shrink' | 'none';
  margin?: { top?: number; right?: number; bottom?: number; left?: number };
  columns?: number;
  columnSpacing?: number;       // points
  textPath?: { preset: string };
}

BulletOptions

interface BulletOptions {
  type?: 'char' | 'auto';
  char?: string;      // e.g. '•', '–'
  color?: Color;
  size?: number;      // percentage of text size
  font?: string;
}

NumberingOptions

interface NumberingOptions {
  type?: 'arabicPeriod' | 'arabicParenR' | 'romanUcPeriod'
       | 'romanLcPeriod' | 'alphaUcPeriod' | 'alphaLcPeriod'
       | 'arabicPlain';
  startAt?: number;   // default 1
  color?: Color;
  size?: number;      // percentage of text size
  font?: string;
}

TabStop

interface TabStop {
  position: number;                       // points from left margin
  alignment?: 'l' | 'ctr' | 'r' | 'dec';
}

---

Images

ImageOptions

interface ImageOptions extends Partial<Placement> {
  path?: string;
  data?: Uint8Array;
  contentType?: string;          // default 'image/png'
  border?: LineProperties;
  effects?: EffectProperties;
  transform?: TransformProperties;
  scene3d?: Scene3DProperties;
  shape3d?: Shape3DProperties;
  opacity?: number;              // 0–100
  crop?: { top?: number; bottom?: number; left?: number; right?: number };
  hyperlink?: HyperlinkProperties;
  sizing?: {
    type: 'contain' | 'cover' | 'crop';
    align?: 'tl' | 'tc' | 'tr' | 'ml' | 'mc' | 'mr' | 'bl' | 'bc' | 'br';
  };
  lockAspectRatio?: boolean;     // default true
  brightness?: number;           // -100 to 100
  contrast?: number;             // -100 to 100
  saturation?: number;           // 0–200 (100 = normal)
  duotone?: { color1: Color; color2: Color };
  cropShape?: PresetGeometry;
}

---

Shapes

PresetGeometry

Over 180 built-in shape types. Common shapes:

Category	Shapes
Basic	'rect', 'roundRect', 'ellipse', 'triangle', 'diamond', 'pentagon', 'hexagon', 'octagon'
Stars	'star4', 'star5', 'star6', 'star7', 'star8', 'star10', 'star12', 'star16', 'star24', 'star32'
Arrows	'arrow', 'leftArrow', 'rightArrow', 'upArrow', 'downArrow', 'leftRightArrow', 'upDownArrow', 'bentArrow', 'curvedRightArrow'
Callouts	'wedgeRectCallout', 'wedgeRoundRectCallout', 'wedgeEllipseCallout', 'cloudCallout'
Flowchart	'flowChartProcess', 'flowChartDecision', 'flowChartTerminator', 'flowChartDocument', 'flowChartConnector'
Math	'mathPlus', 'mathMinus', 'mathMultiply', 'mathDivide', 'mathEqual', 'mathNotEqual'
Lines	'line', 'lineInv', 'straightConnector1'
Fun	'heart', 'smileyFace', 'moon', 'sun', 'cloud', 'lightningBolt'

ShapeOptions

interface ShapeOptions extends Partial<Placement> {
  fill?: Fill;
  line?: LineProperties;
  effects?: EffectProperties;
  transform?: TransformProperties;
  scene3d?: Scene3DProperties;
  shape3d?: Shape3DProperties;
  opacity?: number;                    // 0–100
  text?: string;
  textOptions?: ShapeTextOptions;
  textRunOptions?: TextRunOptions;
  textParagraphOptions?: ParagraphOptions;
  adjustValues?: Record<string, number>;
  hyperlink?: HyperlinkProperties;
  customGeometry?: CustomGeometry;
  locks?: ShapeLocks;
}

ShapeTextOptions

interface ShapeTextOptions {
  verticalAlign?: 'top' | 'middle' | 'bottom';
  wordWrap?: boolean;
  margin?: { top?: number; right?: number; bottom?: number; left?: number };
  autoFit?: boolean | 'shrink' | 'none';
}

CustomGeometry

interface CustomGeometry {
  paths: CustomGeometryPath[];
}

interface CustomGeometryPath {
  w?: number;
  h?: number;
  commands: PathCommand[];
}

type PathCommand =
  | { type: 'moveTo'; x: number; y: number }
  | { type: 'lineTo'; x: number; y: number }
  | { type: 'arcTo'; wR: number; hR: number; stAng: number; swAng: number }
  | { type: 'cubicBezTo'; x1: number; y1: number; x2: number; y2: number; x: number; y: number }
  | { type: 'close' };

ShapeLocks

interface ShapeLocks {
  noGroup?: boolean;
  noRotation?: boolean;
  noMove?: boolean;
  noResize?: boolean;
  noSelect?: boolean;
  noTextEdit?: boolean;
}

---

Tables

TableRow

type TableRow = TableCell[];

TableCell

interface TableCell {
  text: string;
  options?: TextRunOptions & {
    fill?: Fill;
    colSpan?: number;
    rowSpan?: number;
    margin?: { top?: number; right?: number; bottom?: number; left?: number };
    verticalAlign?: 'top' | 'middle' | 'bottom' | 'distributed';
    textBody?: TextBodyOptions;
    borderLeft?: TableCellBorder;
    borderRight?: TableCellBorder;
    borderTop?: TableCellBorder;
    borderBottom?: TableCellBorder;
    align?: 'left' | 'center' | 'right' | 'justify';
  };
}

TableCellBorder

interface TableCellBorder {
  color?: Color;
  width?: number;   // points
}

TableOptions

interface TableOptions extends Partial<Placement> {
  colWidths?: number[];          // inches
  rowHeights?: number[];         // inches
  border?: TableBorderOptions;
  fill?: Fill;
  firstRow?: boolean;
  lastRow?: boolean;
  firstCol?: boolean;
  lastCol?: boolean;
  bandRow?: boolean;
  bandCol?: boolean;
  bandRowColors?: [Color, Color];
  effects?: EffectProperties;
  transform?: TransformProperties;
  tableStyleId?: string;         // built-in table style GUID
}

TableBorderOptions

interface TableBorderOptions {
  color?: Color;
  width?: number;
  left?: TableCellBorder;
  right?: TableCellBorder;
  top?: TableCellBorder;
  bottom?: TableCellBorder;
  insideH?: TableCellBorder;
  insideV?: TableCellBorder;
}

---

Charts

ChartType

type ChartType =
  | 'bar' | 'col' | 'line' | 'pie' | 'area' | 'scatter'
  | 'doughnut' | 'radar' | 'bubble' | 'stock' | 'surface'
  | 'bar3D' | 'col3D' | 'line3D' | 'pie3D' | 'area3D';

ChartData

interface ChartData {
  categories?: string[];
  series: ChartSeries[];
  xValues?: number[];       // scatter/bubble charts
  bubbleSizes?: number[];   // bubble charts
}

ChartSeries

interface ChartSeries {
  name: string;
  values: number[];
  color?: Color;
  colors?: Color[];            // per-data-point (e.g. pie slices)
  lineWidth?: number;          // points
  lineDash?: LineDash;
  marker?: ChartMarkerOptions;
  smooth?: boolean;
  fill?: Color;                // area fill
  opacity?: number;            // 0–100
  trendline?: TrendlineOptions;
  errorBars?: ErrorBarOptions;
  dataLabels?: DataLabelOptions;
  explosion?: number;          // pie/doughnut slice explosion
}

ChartOptions

interface ChartOptions extends Partial<Placement> {
  title?: string;
  showLegend?: boolean;
  showDataLabels?: boolean;
  showGridLines?: boolean;
  titleFontSize?: number;
  titleColor?: Color;
  legendPosition?: 'b' | 't' | 'l' | 'r' | 'tr';
  catAxis?: AxisOptions;
  valAxis?: AxisOptions;
  secondaryValAxis?: AxisOptions;
  plotArea?: { fill?: Color; border?: LineProperties };
  barGapWidth?: number;             // 0–500%
  barOverlap?: number;              // -100 to 100%
  barGrouping?: 'clustered' | 'stacked' | 'percentStacked';
  pieExplosion?: number;            // 0–400%
  doughnutHoleSize?: number;        // 10–90%
  lineGrouping?: 'standard' | 'stacked' | 'percentStacked';
  areaGrouping?: 'standard' | 'stacked' | 'percentStacked';
  scatterStyle?: 'lineMarker' | 'line' | 'marker' | 'smooth' | 'smoothMarker';
  radarStyle?: 'standard' | 'marker' | 'filled';
  border?: LineProperties;
  fill?: Color;
  dataLabels?: DataLabelOptions;
  view3D?: {
    rotX?: number;
    rotY?: number;
    depthPercent?: number;
    rAngAx?: boolean;
    perspective?: number;
  };
}

AxisOptions

interface AxisOptions {
  title?: string;
  titleFontSize?: number;
  min?: number;
  max?: number;
  majorUnit?: number;
  minorUnit?: number;
  orientation?: 'minMax' | 'maxMin';
  labelFontSize?: number;
  labelColor?: Color;
  labelRotation?: number;          // degrees
  format?: string;                 // e.g. '#,##0'
  position?: 'b' | 't' | 'l' | 'r';
  delete?: boolean;                // hide axis
  majorGridlines?: boolean | { color?: Color; width?: number };
  minorGridlines?: boolean | { color?: Color; width?: number };
  crossesAt?: number | 'min' | 'max' | 'auto';
  logBase?: number;                // e.g. 10
}

ChartMarkerOptions

interface ChartMarkerOptions {
  type?: 'circle' | 'square' | 'diamond' | 'triangle' | 'star' | 'x' | 'plus' | 'none';
  size?: number;                   // 2–72
  fill?: Color;
  border?: { color?: Color; width?: number };
}

TrendlineOptions

interface TrendlineOptions {
  type?: 'linear' | 'exp' | 'log' | 'movingAvg' | 'poly' | 'power';
  order?: number;
  period?: number;
  forward?: number;
  backward?: number;
  intercept?: number;
  displayEquation?: boolean;
  displayRSquared?: boolean;
  color?: Color;
  width?: number;
  dash?: LineDash;
}

ErrorBarOptions

interface ErrorBarOptions {
  direction?: 'x' | 'y';
  type?: 'both' | 'plus' | 'minus';
  valueType?: 'fixedVal' | 'percentage' | 'stdDev' | 'stdErr' | 'cust';
  value?: number;
  noEndCap?: boolean;
  color?: Color;
  width?: number;
}

DataLabelOptions

interface DataLabelOptions {
  position?: 'ctr' | 'inEnd' | 'outEnd' | 'bestFit' | 't' | 'b' | 'l' | 'r';
  showValue?: boolean;
  showCategory?: boolean;
  showSeriesName?: boolean;
  showPercent?: boolean;
  separator?: string;
  numberFormat?: string;
  fontSize?: number;
  fontFace?: string;
  color?: Color;
}

---

Media

MediaOptions

interface MediaOptions extends Partial<Placement> {
  path?: string;
  data?: Uint8Array;
  contentType?: string;             // default: 'video/mp4' or 'audio/mpeg'
  poster?: MediaPoster;
  playback?: MediaPlaybackOptions;
  effects?: EffectProperties;
  transform?: TransformProperties;
}

MediaPlaybackOptions

interface MediaPlaybackOptions {
  start?: number;           // ms offset
  end?: number;             // ms offset
  loop?: boolean;
  autoPlay?: boolean;
  mute?: boolean;
  showControls?: boolean;   // default true
  rewind?: boolean;
  fullscreen?: boolean;
}

MediaPoster

interface MediaPoster {
  path?: string;
  data?: Uint8Array;
  contentType?: string;
}

---

Slide Background

SlideBackground

interface SlideBackground {
  fill?: Fill;       // gradient, pattern, or picture background
  color?: Color;     // shortcut for solid color
}

---

Transitions

SlideTransition

interface SlideTransition {
  type?: TransitionType;
  duration?: number;            // ms
  advanceAfter?: number;        // ms (0 = click only)
  advanceOnClick?: boolean;     // default true
  direction?: 'l' | 'r' | 'u' | 'd' | 'lu' | 'ru' | 'ld' | 'rd';
  durationMs?: number;          // raw ms, overrides spd mapping
}

TransitionType

type TransitionType =
  | 'fade' | 'push' | 'wipe' | 'split' | 'cover' | 'uncover'
  | 'strips' | 'blinds' | 'checker' | 'dissolve' | 'comb'
  | 'newsflash' | 'randomBars' | 'circle' | 'diamond' | 'plus'
  | 'wedge' | 'wheel' | 'zoom' | 'cut' | 'random' | 'none';

---

Animations

Animation

interface Animation {
  elementIndex: number;              // 0-based index of target element
  effect: AnimationEffect;
  category?: AnimationCategory;      // default 'entrance'
  trigger?: AnimationTrigger;        // default 'onClick'
  duration?: number;                 // ms (default 500)
  delay?: number;                    // ms
  direction?: string;                // effect-specific variant
  repeatCount?: number | 'indefinite';
  acceleration?: number;             // 0–100
  deceleration?: number;             // 0–100
  motionPath?: string;               // SVG-style, e.g. 'M 0 0 L 1 0'
}

AnimationEffect

type AnimationEffect =
  | 'appear' | 'fade' | 'flyIn' | 'split' | 'wipe' | 'blinds'
  | 'box' | 'checkerboard' | 'circle' | 'diamond' | 'dissolve'
  | 'peek' | 'plus' | 'randomBars' | 'strips' | 'wedge' | 'wheel'
  | 'zoom' | 'grow' | 'shrink' | 'spin' | 'transparency'
  | 'pulse' | 'colorPulse' | 'teeter' | 'bounce' | 'float' | 'swivel';

AnimationTrigger

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

AnimationCategory

type AnimationCategory = 'entrance' | 'exit' | 'emphasis' | 'motionPath';

---

Connectors

ConnectorOptions

interface ConnectorOptions extends Partial<Placement> {
  type?: ConnectorType;           // default 'straight'
  line?: LineProperties;
  startArrow?: LineEndProperties;
  endArrow?: LineEndProperties;
}

ConnectorType

type ConnectorType = 'straight' | 'elbow' | 'curved';

---

Groups

GroupOptions

interface GroupOptions extends Partial<Placement> {}

---

Presentation Properties

SlideShowProperties

interface SlideShowProperties {
  loop?: boolean;
  showNarration?: boolean;
  showAnimation?: boolean;
  useTimings?: boolean;
}

PrintProperties

interface PrintProperties {
  frameSlides?: boolean;
  hiddenSlides?: boolean;
}

PresentationProperties

interface PresentationProperties {
  slideShow?: SlideShowProperties;
  print?: PrintProperties;
}

ViewProperties

interface ViewProperties {
  lastView?: LastViewType;
}

LastViewType

type LastViewType =
  | 'sldView' | 'sldMasterView' | 'notesView'
  | 'handoutView' | 'sldSorterView';

---

Comments & Tags

CommentAuthor

interface CommentAuthor {
  id: number;
  name: string;
  initials: string;
  lastIdx: number;
  clrIdx: number;
}

SlideComment

interface SlideComment {
  authorId: number;
  text: string;
  date?: string;                     // ISO 8601
  position?: { x: number; y: number };
  index?: number;
}

UserDefinedTag

interface UserDefinedTag {
  name: string;
  value: string;
}

SlideSyncData

interface SlideSyncData {
  serverSldId: string;
  serverSldModifiedTime: string;     // ISO 8601
  clientInsertedTime: string;        // ISO 8601
}

---

Theme

Theme

interface Theme {
  name: string;
  colors: ColorScheme;
  fonts: FontScheme;
  extraColorSchemes?: ColorScheme[];
}

ColorScheme

interface ColorScheme {
  dk1: string;  lt1: string;  dk2: string;  lt2: string;
  accent1: string;  accent2: string;  accent3: string;
  accent4: string;  accent5: string;  accent6: string;
  hlink: string;  folHlink: string;
}

FontScheme

interface FontScheme {
  majorFont: string;
  minorFont: string;
  majorEastAsian?: string;
  majorComplexScript?: string;
  minorEastAsian?: string;
  minorComplexScript?: string;
}

Default Exports

import { defaultTheme, defaultColorScheme, defaultFontScheme } from 'pptx-craft';

The default theme uses "Office Theme" with Calibri Light (headings) and Calibri (body).

---

Masters & Layouts

SlideMasterDef

interface SlideMasterDef {
  name: string;
  background?: string;
  elements?: IElement[];
}

SlideLayoutDef

interface SlideLayoutDef {
  name: string;
  type: LayoutType;
  placeholders?: PlaceholderDef[];
}

LayoutType

type LayoutType = 'blank' | 'title' | 'titleAndContent' | 'sectionHeader' | 'twoContent';

PlaceholderDef

interface PlaceholderDef {
  type: PlaceholderType;
  placement: Placement;
  idx?: number;
}

PlaceholderType

type PlaceholderType = 'title' | 'body' | 'ctrTitle' | 'subTitle' | 'dt' | 'ftr' | 'sldNum';

NotesMasterDef

interface NotesMasterDef {
  name?: string;   // default "Default Notes Master"
}

HandoutMasterDef

interface HandoutMasterDef {
  name?: string;   // default "Default Handout Master"
}

---

Plugin System

IPlugin

interface IPlugin {
  name: string;
  install(registry: IRegistry): void;
}

IRegistry

interface IRegistry {
  registerElement<E extends IElement>(type: ElementType, serializer: IElementSerializer<E>): void;
  getSerializer(type: ElementType): IElementSerializer | undefined;
}

IElement

interface IElement {
  readonly type: ElementType;
  placement: Placement;
  name?: string;
}

IElementSerializer

interface IElementSerializer<E extends IElement = IElement> {
  type: ElementType;
  serialize(element: E, ctx: SerializationContext): string;
}

SerializationContext

interface SerializationContext {
  addRelationship(type: string, target: string, data?: Uint8Array): string;
  theme: Theme;
  slideIndex: number;
}

ElementType

type ElementType = string;

Built-in types: 'text', 'image', 'shape', 'table', 'chart', 'media', 'group', 'connector'.