Typeface = ref object
  opentype: OpenType
  svgFont: SvgFont
  filePath*: string
  fallbacks*: seq[Typeface]

Font = ref object
  typeface*: Typeface
  size*: float32             ## Font size in pixels.
  lineHeight*: float32       ## The line height in pixels or autoLineHeight for the font's default line height.
  paints*: seq[Paint]
  textCase*: TextCase
  underline*: bool           ## Apply an underline.
  strikethrough*: bool       ## Apply a strikethrough.
  noKerningAdjustments*: bool ## Optionally disable kerning pair adjustments
  

Span = ref object
  text*: string
  font*: Font

Arrangement = ref object
  lines*: seq[(int, int)]    ## The (start, stop) of the lines of text.
  spans*: seq[(int, int)]    ## The (start, stop) of the spans in the text.
  fonts*: seq[Font]          ## The font for each span.
  runes*: seq[Rune]          ## The runes of the text.
  positions*: seq[Vec2]      ## The positions of the glyphs for each rune.
  selectionRects*: seq[Rect] ## The selection rects for each glyph.
  

HorizontalAlignment = enum
  haLeft, haCenter, haRight

VerticalAlignment = enum
  vaTop, vaMiddle, vaBottom

TextCase = enum
  tcNormal, tcUpper, tcLower, tcTitle

autoLineHeight: float32 = -1.0

proc scale(typeface: Typeface): float32 {...}{.inline, raises: [], tags: [].}

proc ascent(typeface: Typeface): float32 {...}{.raises: [], tags: [].}

proc descent(typeface: Typeface): float32 {...}{.raises: [], tags: [].}

proc lineGap(typeface: Typeface): float32 {...}{.raises: [], tags: [].}

proc lineHeight(typeface: Typeface): float32 {...}{.inline, raises: [], tags: [].}

proc hasGlyph(typeface: Typeface; rune: Rune): bool {...}{.inline, raises: [],
    tags: [].}

proc fallbackTypeface(typeface: Typeface; rune: Rune): Typeface {...}{.raises: [],
    tags: [].}

proc getGlyphPath(typeface: Typeface; rune: Rune): Path {...}{.inline,
    raises: [PixieError], tags: [RootEffect].}

proc getAdvance(typeface: Typeface; rune: Rune): float32 {...}{.inline, raises: [],
    tags: [].}

proc getKerningAdjustment(typeface: Typeface; left, right: Rune): float32 {...}{.
    inline, raises: [], tags: [].}

proc scale(font: Font): float32 {...}{.inline, raises: [], tags: [].}

proc defaultLineHeight(font: Font): float32 {...}{.inline, raises: [], tags: [].}

proc paint(font: Font): Paint {...}{.inline, raises: [], tags: [].}

proc paint=(font: Font; paint: Paint) {...}{.inline, raises: [], tags: [].}

proc newFont(typeface: Typeface): Font {...}{.raises: [], tags: [].}

proc newSpan(text: string; font: Font): Span {...}{.raises: [], tags: [].}

proc typeset(spans: seq[Span]; bounds = vec2(0, 0); hAlign = haLeft;
             vAlign = vaTop; wrap = true): Arrangement {...}{.raises: [], tags: [].}

proc typeset(font: Font; text: string; bounds = vec2(0, 0); hAlign = haLeft;
             vAlign = vaTop; wrap = true): Arrangement {...}{.inline, raises: [],
    tags: [].}

proc computeBounds(arrangement: Arrangement): Vec2 {...}{.raises: [], tags: [].}

proc computeBounds(font: Font; text: string): Vec2 {...}{.inline, raises: [],
    tags: [].}

proc computeBounds(spans: seq[Span]): Vec2 {...}{.inline, raises: [], tags: [].}

proc parseOtf(buf: string): Typeface {...}{.raises: [PixieError], tags: [].}

proc parseTtf(buf: string): Typeface {...}{.raises: [PixieError], tags: [].}

proc parseSvgFont(buf: string): Typeface {...}{.raises: [PixieError],
    tags: [ReadIOEffect, RootEffect, WriteIOEffect].}

proc fillText(target: Image | Mask; arrangement: Arrangement; transform = mat3()) {...}{.
    inline, raises: [PixieError].}

proc fillText(target: Image | Mask; font: Font; text: string;
              transform = mat3(); bounds = vec2(0, 0); hAlign = haLeft;
              vAlign = vaTop) {...}{.inline, raises: [PixieError].}

proc strokeText(target: Image | Mask; arrangement: Arrangement;
                transform = mat3(); strokeWidth: float32 = 1.0;
                lineCap = lcButt; lineJoin = ljMiter;
                miterLimit = defaultMiterLimit; dashes: seq[float32] = @[]) {...}{.
    inline, raises: [PixieError].}

proc strokeText(target: Image | Mask; font: Font; text: string;
                transform = mat3(); strokeWidth: float32 = 1.0;
                bounds = vec2(0, 0); hAlign = haLeft; vAlign = vaTop;
                lineCap = lcButt; lineJoin = ljMiter;
                miterLimit = defaultMiterLimit; dashes: seq[float32] = @[]) {...}{.
    inline, raises: [PixieError].}

proc readTypeface(filePath: string): Typeface {...}{.raises: [PixieError],
    tags: [ReadIOEffect, RootEffect, WriteIOEffect].}

proc readFont(filePath: string): Font {...}{.raises: [PixieError], tags: [
    ReadIOEffect, RootEffect, WriteIOEffect].}