Document model API

This is the symbol reference for the spatial document model: the types a document is made of, their exact fields, and every exported function and method you can call on them. Look a name up here; read The document model for how the model is built and Extracting fields for how it is used.

Three packages are covered — document (the analysed document and its result types), reading (reading-order analysis) and field (form-field detection and field packs). Names are given unqualified when they belong to document, and package-qualified otherwise.

Every symbol here is reachable from both documented surfaces: the kis CLI and the deployed rules.svc. A rule obtains the document with bbox.Get("<name>") and calls these methods on it; the mapping from rule text to method is in The rules bridge.

Conventions

Convention	Rule
Receiver	Methods are on *Document unless the table header says otherwise
Numbers	Method parameters and returns use int64 and float64 only — never int, int32 or float32
Struct fields	Exported fields still use plain int; the numeric contract covers signatures, not fields
Pages	1-indexed. 0 means “every page” on HeaderText, FooterText and Headings
Missing results	Queries return the zero value (empty slice, "", 0, nil) — they do not error
Safe*	Returns a non-nil empty result where the plain variant returns nil

Nothing is populated until Analyze() runs

New copies the pages and the configuration and nothing else. Blocks, Lines, Tables, Fields, Checkboxes, PageLayouts, FontAnalysis, Stats and the spatial index are all nil or zero until Analyze (or AnalyzeParallel) completes, and every query below silently returns empty in that state rather than reporting a problem. Both surfaces analyse every document they load before the first rule is evaluated, so a rule never sees the unanalysed state — this describes what Analyze is responsible for, not a step you perform.

Analyze returns error, but the per-page worker returns nil unconditionally: a malformed document surfaces as empty results, never as an error.

Coordinate types

BoundingBox

type BoundingBox struct {
    X0, Y0 float64 // Top-left corner
    X1, Y1 float64 // Bottom-right corner
}

Top-left origin, Y increasing downward, in raw OCR units. Nothing is normalised to 0..1.

Method	Returns
Width() float64	X1 - X0
Height() float64	Y1 - Y0
Area() float64	Width() * Height()
CenterX() float64	(X0 + X1) / 2
CenterY() float64	(Y0 + Y1) / 2
Left() float64	X0
Right() float64	X1
Top() float64	Y0
Bottom() float64	Y1
IsZero() bool	True when all four coordinates are within 1e-9 of zero
Contains(x, y float64) bool	True when the point is inside, edges included

Point

type Point struct {
    X, Y float64
}

Direction

type Direction int

const (
    DirRight Direction = iota // 0
    DirLeft                   // 1
    DirAbove                  // 2
    DirBelow                  // 3
)

Method or function	Returns
(Direction) String() string	"right", "left", "above", "below", else "unknown"
DirectionFromString(s string) Direction	Parses right, left, above/up, below/down

Two Direction types, same names, different numbers

The geometry layer declares DirLeft=0, DirRight=1, DirAbove=2, DirBelow=3 — left and right are swapped relative to the table above. The library converts between them explicitly, so results are correct, but a direction carried as a number across that boundary flips. Always name a direction with a string. DirectionFromString and its geometry counterpart both return below for an unrecognised string.

Confidence

type Confidence struct {
    Value float64 // Score from 0.0 to 1.0
    Level string  // "VeryLow", "Low", "Medium", "High", "VeryHigh"
}

Method	Returns
IsHigh() bool	Value >= 0.8
IsMedium() bool	Value >= 0.5 && Value < 0.8
IsLow() bool	Value < 0.5
Percent() float64	Value * 100

Level and the predicates cut at different points

Level is bucketed at 0.9 / 0.8 / 0.6 / 0.4; the predicates cut at 0.8 / 0.5. A value of 0.55 reports Level == "Low" and IsMedium() == true simultaneously. Pick one vocabulary per rule set and stay with it.

Content types

Type	Fields
TextBlock	Text string, Box BoundingBox, Confidence float64, Page int
TextLine	Text string, Box BoundingBox, Confidence float64, Page int, IsWrapped bool
DocumentStats	MedianCharWidth, MedianLineHeight, MedianWordGap, MedianLineGap, PageWidth, PageHeight — all float64
PageLayoutResult	Page int, Width float64, Height float64, ColumnCount int, HasHeader bool, HasFooter bool, Margins MarginsResult
MarginsResult	Top, Bottom, Left, Right — all float64
RegionResult	Type string (Header, Footer, MainContent, LeftMargin, RightMargin), Box BoundingBox, Page int, Text string, Confidence float64
DocumentSummary	PageCount, BlockCount, LineCount, TableCount, FieldCount, CheckboxCount, CheckboxGroups — all int — plus Stats text.DocStats

TextBlock is lossy against the analysis-layer block: it drops the source words, the line id and the merge score, so it cannot answer “was this block merged, and from what”. Use the internal-typed accessors when you need that provenance.

Document

type Document struct {
    Pages []ocr.Page

    Stats  text.DocStats
    Blocks []text.Block
    Lines  []text.Line

    Tables         []table.Table
    Fields         []field.Field
    Checkboxes     []checkbox.Checkbox
    CheckboxGroups []checkbox.CheckboxGroup
    PageLayouts    []*region.PageLayout

    SpecialRegions []special.Region
    Signatures     []special.Region
    Handwriting    []special.Region
    Barcodes       []special.Region

    FontAnalysis *font.FontAnalysis
}

Pages is the input; everything else is filled by Analyze. Signatures, Handwriting and Barcodes are projections of SpecialRegions, not separate detections.

Constructors and lifecycle

Method or function	Returns
New(ocrDoc *ocr.Document) *Document	Wraps an OCR document with DefaultConfig(). Does not analyse
NewWithConfig(ocrDoc *ocr.Document, cfg Config) *Document	Same, with explicit settings
DefaultConfig() Config	Every detector on, DPI 300
Analyze() error	Runs the full pipeline. Always returns nil today
AnalyzeParallel(workers int64) error	Per-page parallel analysis; results match the serial path
AnalyzeParallelContext(ctx context.Context, workers int64) error	Cancellable parallel analysis
SetDPI(dpi float64)	Overrides the scan resolution used for point-size conversion
Debug(value bool)	Sets debug logging
Toggledebug()	Flips debug logging
SetSchemas(schemas map[string]*jsonschema.Schema)	Installs named extraction schemas
Schema(name string) *jsonschema.Schema	Returns an installed schema, nil when absent
Summary() DocumentSummary	Counts and statistics for the analysed document
InvalidateReadingCache()	Drops the cached reading-order result

Config

type Config struct {
    MergeWords           bool
    DetectTables         bool
    DetectFields         bool
    DetectCheckboxes     bool
    DetectRegions        bool
    DetectSpecialRegions bool
    AnalyzeFonts         bool
    SpellCheck           bool
    ExtractPatterns      bool
    BuildSpatialIndex    bool
    DPI                  float64
    MergeConfig          text.MergeConfig
}

Field	Default	Effect
MergeWords	true	Glue adjacent OCR words into blocks. Off means one block per word
DetectTables	true	Populates Tables
DetectFields	true	Populates Fields
DetectCheckboxes	true	Populates Checkboxes and CheckboxGroups
DetectRegions	true	Populates PageLayouts
DetectSpecialRegions	true	Populates SpecialRegions and its three projections
AnalyzeFonts	true	Populates FontAnalysis
SpellCheck	false	Declared but never read by the pipeline
ExtractPatterns	true	Declared but never read — pattern extraction is lazy, built on first Find/Has/Count
BuildSpatialIndex	true	Builds the R-tree. Without it the k-nearest, directional and radius queries return nil
DPI	300.0	Point-size conversion basis. <= 0 falls back to 300
MergeConfig	—	Word-merge thresholds

Analysis constants

Constant	Value
DefaultDPI	300.0
DefaultBaselineTolerance	0.3
DefaultAlignTolerance	0.3
DefaultMaxWordGapMultiplier	5.0
DefaultCapHeightRatio	0.72
DefaultXHeightRatio	0.50
DefaultAscenderRatio	0.85
DefaultMaxLabelLength	50
DefaultFontSizeRoundingPrecision	10.0
DefaultFuzzyDistance	2
DefaultMaxGap	5
UnlimitedDistance	-1 (float64)

Walking the document

Wrapper-typed accessors

These return the flat wrapper types above.

Method	Returns
GetBlocks() []TextBlock	Every block in the document
GetLines() []TextLine	Every reconstructed line
GetPageBlocks(pageNum int64) []TextBlock	Blocks on one page
GetPageTextLines(pageNum int64) []TextLine	Lines on one page
FindTextBlocks(search string) []TextBlock	Blocks containing the text
FindAnchorBlocks(anchorText string) []TextBlock	Blocks matching an anchor
FindFuzzyBlocks(search string, maxDist int64) []TextBlock	Blocks within an edit distance
GetHeadingTextBlocks() []TextBlock	Blocks classified as headings
GetBlocksByFontSizeRange(minPt, maxPt float64) []TextBlock	Blocks inside a point-size band
GetDocumentStats() DocumentStats	The six document medians and page dimensions

Internal-typed accessors

These return the analysis types instead of the wrappers, keeping provenance.

Method	Returns
GetPage(pageNum int64) []text.Block	Merged blocks on one page
GetPageLines(pageNum int64) []text.Line	Reconstructed lines on one page
GetField(label string) *field.Field	A detected field by label
GetTable(containing string) *table.Table	The first table containing the text
GetPageLayout(pageNum int64) *region.PageLayout	Full layout record for a page
GetHeader(pageNum int64) *region.Region	Header region
GetFooter(pageNum int64) *region.Region	Footer region
GetMainContent(pageNum int64) *region.Region	Main-content region
GetCheckboxByLabel(label string) *checkbox.Checkbox	A detected checkbox
GetCheckboxGroup(name string) *checkbox.CheckboxGroup	A detected checkbox group
GetCheckedValue(groupName string) []string	Selected labels in a group
ExtractByDefinition(def field.FieldDef) *field.Field	Extract one field from an explicit definition
ExtractRegisteredFields() map[string]*field.Field	Extract every field definition registered by a pack

Layout and regions

Method	Returns
GetLayout(pageNum int64) *PageLayoutResult	Page dimensions, column count, header/footer flags, margins
GetHeaderRegion(pageNum int64) *RegionResult	Header region with its text
GetFooterRegion(pageNum int64) *RegionResult	Footer region with its text
GetMainContentRegion(pageNum int64) *RegionResult	Main-content region with its text

Lines

Method	Returns
AllLines() []string	Every line’s text
LineCount() int64	Number of lines
BlockCount() int64	Number of blocks
LineAt(index int64) string	Line by 0-based index
FirstLine() string / LastLine() string	First and last line
TopLines(n int64) []string / BottomLines(n int64) []string	First and last n lines
LineContaining(text string) string	First line containing the text
FullLineContaining(text string) string	The whole line containing the text, untrimmed
LineNumberOf(text string) int64	Index of the first line containing the text
LineNumbersOf(text string) []int64	Indexes of every matching line
LinesContaining(text string) []string	Every line containing the text
LinesMatching(pattern string) []string	Every line matching a regular expression
LineRange(start, end int64) []string	Lines in an index range
LinesAfter(anchorText string, n int64) []string	n lines after an anchor
LinesBefore(anchorText string, n int64) []string	n lines before an anchor
LinesBetween(startText, endText string) []string	Lines between two anchors

Counts

Method	Returns
PageCount() int64	Highest page number across blocks
FieldCount() int64	Detected fields
TableCount() int64	Detected tables
CheckboxCount() int64	Detected checkboxes
SignatureCount() int64	Detected signatures
BarcodeCount() int64	Detected barcodes
ColumnCount() int64	Detected columns
CountOccurrences(text string) int64	Occurrences of a string

PageCount() is not len(Pages)

The analysis-layer PageCount() int64 is the maximum Page value across blocks. It is 0 before Analyze() and 0 for a document whose pages carry no words. The OCR-layer Document.PageCount() int is the real page count.

Spatial queries

Wrapper-typed, using BoundingBox and Point:

Method	Returns
BlocksInBox(box BoundingBox) []TextBlock	Blocks fully inside the box
BlocksIntersectingBox(box BoundingBox) []TextBlock	Blocks overlapping the box
NearestBlocks(point Point, k int64) []TextBlock	The k nearest blocks
NearestBlockIn(from BoundingBox, dir Direction, maxDist, margin float64) *TextBlock	Nearest block in a direction
BlocksNearPoint(center Point, radius float64) []TextBlock	Blocks within a radius

Geometry-typed equivalents, returning text.Block:

Method	Returns
BlocksInRegion(region geometry.Box) []text.Block	Blocks fully inside the region
BlocksIntersecting(region geometry.Box) []text.Block	Blocks overlapping the region
KNearestBlocks(point geometry.Point, k int64) []text.Block	The k nearest blocks
NearestBlockInDirection(from geometry.Box, dir geometry.Direction, maxDist, margin float64) *text.Block	Nearest block in a direction
BlocksWithinRadius(center geometry.Point, radius float64) []text.Block	Blocks within a radius

KNearestBlocks, NearestBlockInDirection and BlocksWithinRadius all read the R-tree — they return nil when Config.BuildSpatialIndex was off.

Anchor-relative and region queries

Each returns a chainable query.QueryResult.

Method	Anchor semantics
After(anchorText string) query.QueryResult	Right-of first, then below
Below(anchorText string) query.QueryResult	Directly below
Above(anchorText string) query.QueryResult	Directly above
RightOf(anchorText string) query.QueryResult	Directly right
LeftOf(anchorText string) query.QueryResult	Directly left
Near(anchorText string) query.QueryResult	Any direction, nearest first
QueryBetween(startText, endText string) query.QueryResult	Between two anchors
InRegion(x0, y0, x1, y1 float64) query.QueryResult	Absolute coordinates
InRegionPct(x0Pct, y0Pct, x1Pct, y1Pct float64) query.QueryResult	Percentages of the page

Percentage regions collapse to nothing when page dimensions are zero

InRegionPct scales by Stats.PageWidth and Stats.PageHeight. When a page declares no size and the extent fallback cannot recover one, both stay zero, the region becomes (0,0,0,0) and every percentage query matches nothing — with no error anywhere. On a multi-page document the two values are an average across pages, so mixing letter and legal pages scales every percentage query against a page size that matches none of them.

QueryResult carries Blocks []text.Block, Box geometry.Box, Found bool, Page int64 and these accessors:

Method	Returns
Text(), Lines(), Count(), IsEmpty()	Text, line list, block count, emptiness
FirstText(), FirstNumber(), FirstCurrency(), FirstDate(), FirstValue()	First match, typed
Containing(substr), MatchingPattern(pattern), Filter(predicate)	Narrowing
ContainingPhraseFuzzy, ContainingIPhraseFuzzy, ContainingAnyPhraseFuzzy, ContainingAnyIPhraseFuzzy	Fuzzy narrowing, each (phrase string, maxDistPerWord, maxTotalDist int64)

Reading order

On the document

Method	Returns
ReadAll() string	Whole document in reading order
ReadPage(page int64) string	One page in reading order
MainContent() string	Main-content region text
BodyText() string	Body text, headers and footers excluded
HeaderText(page int64) string / FooterText(page int64) string	Region text; 0 means all pages
InHeader(text string) bool / InFooter(text string) bool	Region containment
Contains(text string) bool	Reading-order text contains the string
ContainsAll(texts ...string) bool / ContainsAny(texts ...string) bool	All / any
Title() string	Detected title, "" when none
HasTitle(text string) bool / TitleContains(text string) bool	Exact / substring
TitleMatches(pattern string) bool	Regular expression against the title
Outline() []reading.OutlineEntry	Nested heading structure
Headings(level int64) []string	Headings at a level; 0 returns every level
AllHeadings() []string	Every heading
Sections() []reading.Section	Logical sections
Section(heading string) *reading.Section	One section; falls back to a case-insensitive substring match and recurses into subsections
TextUnder(heading string) string	Text under a heading
TextBetween(startHeading, endHeading string) string	Text between two headings
Columns() []reading.Column / Column(index int64) *reading.Column	Detected columns
IsMultiColumn() bool / IsMultiPage() bool	Shape predicates

The reading result is computed once and cached. InvalidateReadingCache() drops it.

The reading package

type AnalyzerConfig struct {
    DetectColumns  bool // default true
    DetectHeadings bool // default true
    RespectRegions bool // default true; declared but never read
    MaxColumns     int  // default 4; 0 means auto
}

Method or function	Returns
DefaultAnalyzerConfig() AnalyzerConfig	The defaults above
NewAnalyzer() *Analyzer	Analyzer with defaults
NewAnalyzerWithConfig(config AnalyzerConfig) *Analyzer	Analyzer with explicit settings
(*Analyzer) Analyze(blocks []text.Block, docStats text.DocStats) *ReadingResult	Full analysis using document medians
(*Analyzer) AnalyzeWithMedian(blocks []text.Block, medianHeight, medianCharWidth float64) *ReadingResult	Analysis with explicit medians
(*Analyzer) QuickAnalyze(blocks []text.Block) *ReadingResult	Analysis with medians derived from the blocks

Type	Fields
ReadingResult	Blocks []ReadingBlock, Outline []OutlineEntry, Sections []Section, Columns []Column, Title string, PageCount int
ReadingBlock	embeds text.Block; ContentType ContentType, ReadingOrder int, Level int, Column int, RegionType RegionType
OutlineEntry	Text string, Level int, Box geometry.Box, Page int, Children []OutlineEntry, ContentStart int, ContentEnd int
Section	Heading string, Level int, Blocks []ReadingBlock, Subsections []Section, Box geometry.Box, Page int
Column	Index int, Box geometry.Box, Blocks []ReadingBlock, Page int

Method	Returns
(*ReadingResult) Text() string	Every block’s text, newline-joined
(*ReadingResult) TextByPage(page int) string	One page, newline-joined
(*ReadingResult) Headings(level int) []string	Headings at a level; 0 returns all
(*Section) Text() string	Heading plus content plus subsections
(*Section) TextWithOptions(includeHeading bool, lineSeparator string) string	Same, configurable
(*Column) Text() string / (*Column) Lines() []string	Column text as one string or per block

Classification enums:

Type	Values
ContentType	ContentUnknown, ContentTitle, ContentHeading, ContentSubheading, ContentBody, ContentCaption, ContentFootnote, ContentPageNumber, ContentListItem, ContentTableCell
RegionType	RegionUnknown, RegionHeader, RegionBody, RegionFooter, RegionLeftMargin, RegionRightMargin

Both have String() string returning the name without the prefix ("Heading", "Footer").

Reading-order constants: HeaderRegionRatio 0.12, FooterRegionRatio 0.10, TitleSearchRegionRatio 0.35, TitleFontSizeMultiplier 1.5, HeadingFontSizeMultiplier 1.2, ColumnGapMinMultiplier 3.0, SameLineTolerance 0.3.

Region bands ignore the declared page size

The analyser computes its own page width and height as 1.05× the maximum X1/Y1 across every block in the document. It never reads the page’s declared dimensions. The header band (top 12%), footer band (bottom 10%), margin bands and title search region are therefore relative to the pooled printed extent, so classification drifts on a document whose last page is short or whose pages differ in size.

Text and phrase search

Containment

Method	Returns
ContainsText(text string) bool	Substring anywhere
ContainsAnyText(texts ...string) bool / ContainsAllText(texts ...string) bool	Any / all

Exact phrases

Method	Returns
HasPhrase(phrase string) bool	Multi-word phrase present
HasPhraseOnPage(phrase string, page int64) bool	Scoped to a page
HasPhraseInBox(phrase string, box geometry.Box) bool	Scoped to a box
HasAnyPhrase(phrases ...string) bool / HasAllPhrases(phrases ...string) bool	Any / all
HasAnyPhraseOnPage(page int64, phrases ...string) bool	Any, page-scoped
HasAnyPhraseInBox(box geometry.Box, phrases ...string) bool	Any, box-scoped
CountPhrase(phrase string) int64	Occurrences
CountPhraseOnPage(phrase string, page int64) int64	Occurrences on a page
PhraseNear(a, b string, maxPixels float64) bool	Two phrases within a pixel distance
PhraseBetween(startAnchor, endAnchor string) string	Text between two phrases
FindPhrase(phrase string, linesBefore, linesAfter int64) []PhraseMatch	Matches with line context
FindIPhrase(phrase string, linesBefore, linesAfter int64) []PhraseMatch	Same, case-insensitive

Fuzzy phrases

Method	Returns
HasPhraseFuzzy(phrase string, maxDistancePerWord int64) bool	Present within an edit distance
HasPhraseOnPageFuzzy(phrase string, page int64, maxDistancePerWord int64) bool	Page-scoped
HasPhraseInBoxFuzzy(phrase string, box geometry.Box, maxDistancePerWord int64) bool	Box-scoped
HasAnyPhraseFuzzy(maxDistancePerWord int64, phrases ...string) bool	Any
HasAllPhrasesFuzzy(maxDistancePerWord int64, phrases ...string) bool	All
CountPhraseFuzzy(phrase string, maxDistancePerWord int64) int64	Occurrences
FindPhraseFuzzy(phrase string, maxDistancePerWord, maxTotalDistance, linesBefore, linesAfter int64) []FuzzyPhraseMatch	Matches with distances
FindIPhraseFuzzy(phrase string, maxDistancePerWord, maxTotalDistance, linesBefore, linesAfter int64) []FuzzyPhraseMatch	Same, case-insensitive

type PhraseMatch struct {
    Phrase      string       // The matched phrase text
    Page        int          // Page number where found
    Box         geometry.Box // Bounding box of the phrase
    LineIndex   int          // Index of the line containing the phrase
    MatchedLine string       // Full text of the line containing the match
    LinesBefore []string     // Lines before the match (context)
    LinesAfter  []string     // Lines after the match (context)
    Blocks      []text.Block // The blocks that form this phrase
}

type FuzzyPhraseMatch struct {
    PhraseMatch
    TotalDistance int      // Total edit distance across all words
    MatchedWords  []string // The actual words that matched
}

Block and n-gram search

Method	Returns
FindText(search string) []text.Block	Blocks containing the text
FindAnchor(anchorText string) []text.Block	Blocks matching an anchor
FindFuzzy(search string, maxDist int64) []text.Block	Blocks within an edit distance
FindNgram(tokens ...string) []anchor.NgramMatch	Unordered n-gram matches
FindNextFuzzy(search string, fuzzymaxDist int64, from geometry.Box, dir geometry.Direction, maxDistance float64) *text.Block	Next fuzzy match in a direction
FindNextFuzzyWithNgram(search string, fuzzymaxDist int64, from geometry.Box, dir geometry.Direction, maxDistance float64) *anchor.NgramMatch	Same, returning the n-gram match
ExtractAfter(label string, dir anchor.RelativeDir) []text.Block	Blocks after a label in a relative direction

Snippets

Method	Returns
ExtractSnippet(startPhrase, endPhrase string, caseInsensitive, includeEnd bool) *Snippet	Text between two phrases, across pages. nil when the start phrase is absent
ExtractSnippetFuzzy(startPhrase, endPhrase string, caseInsensitive, includeEnd bool, maxDist int64) *Snippet	Same, fuzzy

type Snippet struct {
    StartPhrase string   // The starting phrase that was matched
    EndPhrase   string   // The ending phrase that was matched
    StartPage   int      // Page where the start phrase was found
    EndPage     int      // Page where the end phrase was found
    Lines       []string // The extracted lines of text
}

The start phrase is included; the end phrase is excluded unless includeEnd is true.

Anchor-walk extraction

Method	Returns
GetOCRText(expr string, opts OCRTextOptions) string	Text found by walking an anchor expression
GetOCRTextWithContext(ctx context.Context, expr string, opts OCRTextOptions) string	Cancellable variant
GetOCRTextSimple(expr string, direction string, ngramMaxDistance float64, maxDistance float64, margin float64) string	Same, with the options flattened to primitives
FindMatchingBlock(expr string, ngramMaxDistance float64) *text.Block	The block an expression resolves to
FindMatchingBlockWithContext(ctx context.Context, expr string, ngramMaxDistance float64) *text.Block	Cancellable variant

type OCRTextOptions struct {
    Direction        geometry.Direction // search direction from the matched anchor
    NgramMaxDistance float64            // 0 = unlimited
    MaxDistance      float64            // -1 = unlimited
    Margin           float64            // padding added to the search area
}

DefaultOCRTextOptions() OCRTextOptions returns DirBelow, 0, UnlimitedDistance, 0.

Patterns

Generic dispatch

Method	Returns
Find(patternName string) []PatternMatch	Every match of a named pattern
FindFirst(patternName string) string	First match, "" when none
Has(patternName string) bool	Any match
Count(patternName string) int64	Match count
FindPattern(pattern string) []PatternMatch	Matches of an explicit pattern
FindPatternFirst(pattern string) string	First explicit-pattern match
HasPattern(pattern string) bool / PatternCount(pattern string) int64	Presence and count
ExtractPatterns() []pattern.Match	Every pattern match in the document
ExtractDates() []pattern.Match / ExtractCurrency() []pattern.Match	Typed extraction

type PatternMatch struct {
    Value      string       // The matched text
    Box        geometry.Box // Bounding box of the matched text
    Page       int          // Page number where the match was found
    BlockIndex int          // Index of the block containing the match
}

Multi-block patterns

A value split across blocks by OCR is only found by the spanning family.

Method	Returns
FindSpanning(patternName string) []pattern.BlockMatch	Matches spanning blocks
FindSpanningAll() []pattern.BlockMatch	Every spanning match
HasSpanning(patternName string) bool / CountSpanning(patternName string) int64	Presence and count

Built-in pattern types

Fifteen types have a dedicated four-method set. Every method takes no arguments; the four signatures are the same for every type:

func (d *Document) Find<T>() []PatternMatch
func (d *Document) Find<T>First() string
func (d *Document) Has<T>() bool
func (d *Document) <T>Count() int64

Type	All matches	First match	Presence	Count
SSN	FindSSN()	FindSSNFirst()	HasSSN()	SSNCount()
Phone	FindPhone()	FindPhoneFirst()	HasPhone()	PhoneCount()
Email	FindEmail()	FindEmailFirst()	HasEmail()	EmailCount()
Date	FindDate()	FindDateFirst()	HasDate()	DateCount()
Currency	FindCurrency()	FindCurrencyFirst()	HasCurrency()	CurrencyCount()
Percentage	FindPercentage()	FindPercentageFirst()	HasPercentage()	PercentageCount()
Account number	FindAccountNumber()	FindAccountNumberFirst()	HasAccountNumber()	AccountNumberCount()
Routing number	FindRoutingNumber()	FindRoutingNumberFirst()	HasRoutingNumber()	RoutingNumberCount()
ZIP code	FindZipCode()	FindZipCodeFirst()	HasZipCode()	ZipCodeCount()
EIN	FindEIN()	FindEINFirst()	HasEIN()	EINCount()
Street address	FindStreetAddress()	FindStreetAddressFirst()	HasStreetAddress()	StreetAddressCount()
State	FindState()	FindStateFirst()	HasState()	StateCount()
ITIN	FindITIN()	FindITINFirst()	HasITIN()	ITINCount()
VIN	FindVIN()	FindVINFirst()	HasVIN()	VINCount()
Policy number	FindPolicyNumber()	FindPolicyNumberFirst()	HasPolicyNumber()	PolicyNumberCount()

FindDate and ExtractDates are different functions

FindDate() []PatternMatch and FindCurrency() []PatternMatch are the pattern-family methods above. ExtractDates() []pattern.Match and ExtractCurrency() []pattern.Match return the analysis-layer match type instead. The names are close; the return types are not interchangeable.

Fields

Reading a field

Method	Returns
Field(label string) query.FieldResult	A detected field by label
FieldByPattern(labelPattern string) query.FieldResult	By regular expression over labels
AllFields() []field.Field	Every detected field
FieldExists(label string) bool	Presence
FieldValue(label string) string	Value as text
FieldEquals(label, expected string) bool / FieldContains(label, substr string) bool	Comparison
FieldNumber(label string) float64 / FieldCurrency(label string) float64	Numeric parse
ExtractFields(fieldLabels ...string) *FormData	Several fields plus every table

type FormData struct {
    Fields map[string]query.FieldResult
    Tables []*TableResult
}

Method	Returns
(*FormData) Get(label string) query.FieldResult	One field
(*FormData) Table(index int) *TableResult	One table
(*FormData) HasField(label string) bool	Field was found
(*FormData) MissingFields() []string	Labels with no value
(*FormData) IsComplete() bool	Nothing missing
(*FormData) ToMap() map[string]string	Flat label-to-value map

Spatial field extraction

Method	Returns
TextRightOf(anchorText string) string	Text to the right of an anchor
TextBelow(anchorText string) string	Text below an anchor
TextAbove(anchorText string) string	Text above an anchor
TextLeftOf(anchorText string) string	Text to the left of an anchor
NumberRightOf(anchorText string) float64	Numeric parse of TextRightOf
NumberBelow(anchorText string) float64	Numeric parse of TextBelow
CurrencyRightOf(anchorText string) float64	Currency parse of TextRightOf
CurrencyBelow(anchorText string) float64	Currency parse of TextBelow
FuzzyTextNear(label string, dir Direction, maxDistPerWord, maxTotalDist int64, expand float64) string	Fuzzy label, text in a direction
FuzzyTextNearCapped(label string, dir Direction, maxDistPerWord, maxTotalDist int64, expand, maxExtent float64) string	Same, with a hard extent cap
FuzzyTextNearChain(chain string, valueDir Direction, maxDistPerWord, maxTotalDist int64, expand float64) string	Multi-hop anchor chain
FuzzyTextNearChainCapped(chain string, valueDir Direction, maxDistPerWord, maxTotalDist int64, expand, maxExtent float64) string	Chain with an extent cap
FuzzyTextNearChainScaled(chain string, valueDir Direction, maxDistPerWord, maxTotalDist int64, expand, multiplier float64) string	Chain with a scaled search region
FuzzyTextAtIntersection(rowLabel, colLabel string, maxDistPerWord, maxTotalDist int64, expand float64) string	Value at a row/column crossing
HasFuzzyChain(chain string, maxDistPerWord, maxTotalDist int64, searchMultiplier, maxSearchPx, sideExtMultiplier float64) bool	Chain resolves
HasIFuzzyChain(chain string, maxDistPerWord, maxTotalDist int64, searchMultiplier, maxSearchPx, sideExtMultiplier float64) bool	Same, case-insensitive

A chain is |-delimited, every segment but the last carrying a direction in angle brackets — "Loan Information<below>|Loan Term".

Confidence-scored extraction

Method	Returns
FieldNear(label string, dir Direction, maxDistPerWord, maxTotalDist int64, expand float64) query.FieldResult	Scored spatial extraction
FieldNearCapped(label string, dir Direction, maxDistPerWord, maxTotalDist int64, expand, maxExtent float64) query.FieldResult	Scored, extent-capped
FieldNearChain(chain string, valueDir Direction, maxDistPerWord, maxTotalDist int64, expand float64) query.FieldResult	Scored chain
FieldNearChainCapped(chain string, valueDir Direction, maxDistPerWord, maxTotalDist int64, expand, maxExtent float64) query.FieldResult	Scored chain, extent-capped
ScoredField(label string) query.FieldResult	Right-of and below, higher score wins
ScoredFieldOnPage(label string, page int64) query.FieldResult	Same, page-scoped
ExtractFieldsScored(labels []string) map[string]query.FieldResult	Several fields, scored
ExtractFieldsScoredOnPage(labels []string, page int64) map[string]query.FieldResult	Same, page-scoped
ExtractFieldsJSON(labels []string) string	JSON object of ScoredValue
ExtractFieldsJSONOnPage(labels []string, page int64) string	Same, page-scoped

type ScoredValue struct {
    Value      string  `json:"value"`
    Confidence float64 `json:"confidence"`      // 0..1
    Found      bool    `json:"found"`
    Page       int64   `json:"page,omitempty"`
    Method     string  `json:"method,omitempty"` // e.g. "field.right_of", "field.below"
}

query.FieldResult carries Value, Label, Box, LabelBox, Conf, Prov, Found and Page. Read it with AsText, AsNumber, AsCurrency, AsPercent, AsPercentRaw, AsInt, AsBool, AsDate; test it with IsEmpty, Equals, Contains, Matches, OneOf, GreaterThan, LessThan, Between, Before, After; and inspect the score with Confidence, ConfidencePct, ConfidenceScore, IsConfident, NeedsReview, Explain, Provenance. Required, Optional, Or, OrDefault, WithConfidence and WithProvenance return a modified copy.

Repeating records

Method	Returns
ExtractRepeatingFields(labels ...string) []field.Record	One record per repeat of the label set
RepeatingExtractingFields(repextractFields string, extractMaxLines, extractMaxWords int64, extractEnd, extractFieldWords, extractVerticalFields string) []map[string]any	Same, driven entirely by strings

Column-aligned sections

Method or function	Returns
(*Document) ExtractColumnAlignedSection(sectionStart, sectionEnd, columnHeaders string) []map[string]any	Rows read from a columnar section
PostprocessRows(rows []map[string]any, key string, fn string) []map[string]any	Package function; applies a named transform to one key in every row

fn accepts trim, upper, lower, normalize_spaces, trim_currency, and the dynamic form ExtractRegex("pattern", "defaultVal"). An unknown fn returns the rows untouched. Call it again to chain a second transform on the same key.

The field package

type Field struct {
    Label      string
    Value      string
    LabelBox   geometry.Box
    ValueBox   geometry.Box
    Relation   RelationType
    Confidence float64          // overall confidence

    LabelConfidence confidence.Score
    ValueConfidence confidence.Score
    OverallScore    confidence.Score

    PatternType pattern.PatternType
    Normalized  any
}

type FieldDef struct {
    Name          string
    LabelPatterns []string        // regular expressions for the label
    LabelAnchors  []*anchor.Ngram // n-gram anchors for the label
    ValueType     pattern.PatternType
    LocationHint  RelationType
    Required      bool
    Validator     func(string) bool
}

Type	Fields
FieldGroup	Name string, Fields []Field, Box geometry.Box
Pack	Name string, Fields []FieldDef
Record	Fields map[string]string, Line text.Line
Detector	No exported fields
RelationType	RelInline, RelRightOf, RelBelow, RelTableCell

Method or function	Returns
NewDetector() *Detector	A detector with default pattern, anchor and fuzzy settings
(*Detector) DetectFields(blocks []text.Block, lines []text.Line) []Field	Inline, right-of and below detection, deduplicated
(*Detector) ExtractByDefinition(def FieldDef, blocks []text.Block, lines []text.Line) *Field	One field from an explicit definition
GroupFields(fields []Field, maxGap float64) []FieldGroup	Clusters fields by vertical proximity
(*Field) ComputeOverallConfidence()	Sets OverallScore and Confidence from a 0.4/0.6 weighting of label and value

Field packs carry the vertical vocabulary; the library itself is domain-neutral.

Function	Returns
RegisterPack(p Pack)	Appends a pack. Concurrency-safe; duplicate names are not rejected
RegisteredPacks() []Pack	Snapshot in registration order
RegisteredFieldDefs() []FieldDef	Every definition across every pack
RegisteredFieldDef(name string) *FieldDef	First match by name, case-insensitive; nil when absent
ResetPacks()	Empties the registry

When two packs define the same field name, RegisteredFieldDef returns the one registered first — later registrations do not override earlier ones.

Repeating extraction is configured with a chainable builder:

Method or function	Returns
NewRepeatingFieldExtractor(labels ...string) *RepeatingFieldExtractor	Package function; MaxLines 10, MaxWords 3, MinMatchRatio 0.5
(*RepeatingFieldExtractor) SetEndMarkers(markers ...string) *RepeatingFieldExtractor	Text that ends a record
(*RepeatingFieldExtractor) SetMaxLines(n int) *RepeatingFieldExtractor	Lines per record
(*RepeatingFieldExtractor) SetMaxWords(n int) *RepeatingFieldExtractor	Default words per value
(*RepeatingFieldExtractor) SetFieldMaxWords(label string, n int) *RepeatingFieldExtractor	Words for one field
(*RepeatingFieldExtractor) SetVerticalFields(labels ...string) *RepeatingFieldExtractor	Fields whose value sits below the label
(*RepeatingFieldExtractor) Extract(lines []text.Line) []Record	One record per repeat

type RepeatingFieldExtractor struct {
    Labels         []string
    EndMarkers     []string
    VerticalFields []string
    MaxLines       int
    MaxWords       int
    FieldMaxWords  map[string]int
    MinMatchRatio  float64
}

Field-detection constants: DefaultMaxLabelLength 50, DefaultShortLabelLength 20, DefaultLabelConfidenceNormalizationFactor 100.0, DefaultGapToWidthMultiplier 3.0, DefaultAlignmentToleranceRatio 0.5, DefaultBaselineTolerance 0.3, DefaultBaseLabelScore 0.5, DefaultColonBoost 0.3, DefaultShortLabelBoost 0.1, DefaultCapitalBoost 0.1, DefaultDigitPenalty 0.2, DefaultPatternMatchConfidence 0.95.

Tables

Locating a table

Method	Returns
AllTables() []table.Table	Every detected table
FirstTable() *table.Table	The first table
TableAt(index int64) *table.Table	By index
TableNear(anchorText string) *table.Table	Nearest to an anchor
TableNearPhrase(anchorPhrase string) *table.Table	Nearest to a phrase
HasTables() bool	Any table detected
Table(index int64) *TableResult	By index, wrapped
TableContaining(text string) *TableResult	First table containing the text
SafeTable(index int64) *SafeTableResult	By index, nil-safe
WrapTable(t *table.Table) *TableResult	Wraps a table; nil in, nil out

Tables located by anchor

Method	Returns
TableBelow(anchor string) *TableResult	First table below an anchor
TableAbove(anchor string) *TableResult	First table above an anchor
TableBetween(startAnchor, endAnchor string) *TableResult	Table between two anchors
TablesBetween(startAnchor, endAnchor string) []*TableResult	Every table between two anchors
TableBelowFuzzy(anchor string, maxDistPerWord, maxTotalDist int64) *TableResult	Fuzzy anchor
TableAboveFuzzy(anchor string, maxDistPerWord, maxTotalDist int64) *TableResult	Fuzzy anchor
TableBetweenFuzzy(startAnchor, endAnchor string, maxDistPerWord, maxTotalDist int64) *TableResult	Fuzzy anchors

Nil-safe variants of the same lookups:

Method	Returns
SafeTableBelow(anchor string) *SafeTableResult	First table below an anchor
SafeTableAbove(anchor string) *SafeTableResult	First table above an anchor
SafeTableBetween(startAnchor, endAnchor string) *SafeTableResult	Table between two anchors
SafeTableBelowFuzzy(anchor string, maxDistPerWord, maxTotalDist int64) *SafeTableResult	Fuzzy anchor
SafeTableAboveFuzzy(anchor string, maxDistPerWord, maxTotalDist int64) *SafeTableResult	Fuzzy anchor
SafeTableBetweenFuzzy(startAnchor, endAnchor string, maxDistPerWord, maxTotalDist int64) *SafeTableResult	Fuzzy anchors
SafeTablesBetween(startAnchor, endAnchor string) []*TableResult	Every table between two anchors

SafeTablesBetween adds no safety

Every other SafeTable* method returns *SafeTableResult. SafeTablesBetween returns []*TableResult and its body is a direct call to TablesBetween — the name is the only difference. Each element dereferences like a plain TableResult.

TableResult

TableResult embeds *table.Table.

Method	Returns
Row(index int) *RowResult	Row by index, headers included
DataRow(index int) *RowResult	Row by index, headers excluded
DataRowCount() int	Rows excluding headers
Headers() []string / HasHeaders() bool	Header row
CellValue(row, col int) string	Cell by position
DataCell(row, col int) string	Cell by position, headers excluded
CellByHeader(row int, header string) string	Cell by row index and header name
ColumnByIndex(index int) []string / ColumnByName(header string) []string	Column values
ColumnData(colIndex int) []string	Column values excluding the header
FindRow(text string) *RowResult	First row containing the text
FindColumn(text string) int	Index of the column containing the text, -1 when absent
RowsAsMaps() []map[string]string	Rows keyed by header
AsMap() map[string][]string	Columns keyed by header
IsColumnRightAligned(colIndex int) bool / IsColumnLeftAligned(colIndex int) bool	Alignment tests
ColumnAlignment(colIndex int) string	Alignment name
RightAlignedColumns() []int	Indexes of right-aligned columns — usually the numeric ones

RowResult embeds *table.Row and adds three accessors:

Method	Returns
(*RowResult) Cell(col int) string	Cell by column index
(*RowResult) CellByHeader(header string) string	Cell by header name
(*RowResult) Values() []string	Every cell in the row

SafeTableResult

SafeTableResult embeds *TableResult and returns empties instead of nil dereferences.

Method	Returns
Row(index int) *SafeRowResult / DataRow(index int) *SafeRowResult	Never nil
Cell(row, col int) string / DataCell(row, col int) string	"" when absent
CellByHeader(row int, header string) string	"" when absent
RowCount() int, DataRowCount() int, ColumnCount() int	0 on an absent table
HasData() bool / IsEmpty() bool	Emptiness
RowsAsMaps() []map[string]string / AsMap() map[string][]string	Empty on an absent table

SafeRowResult embeds *RowResult and overrides its accessors to be nil-safe.

Method	Returns
(*SafeRowResult) Cell(col int) string	"" when absent
(*SafeRowResult) CellByHeader(header string) string	"" when absent
(*SafeRowResult) Values() []string	Empty slice on an absent row
(*SafeRowResult) IsEmpty() bool	True on an absent row

CellResult

type CellResult struct {
    Row        int         // Row index (0-based)
    Col        int         // Column index (0-based)
    Text       string      // Cell text content
    Box        BoundingBox // Cell bounding box
    IsHeader   bool        // True if this is a header cell
    Confidence float64     // Detection confidence
}

Method	Returns
AsText() string	Trimmed text
AsNumber() float64	Number, 0 on a parse failure
AsCurrency() float64	Currency with symbols and separators stripped
AsPercent() float64	Percentage
AsInt() int	Integer
AsDate() time.Time	Date, zero time on a parse failure
IsEmpty() bool	No text
Contains(substr string) bool / Equals(text string) bool	Comparison

Every accessor is nil-safe on the receiver.

Checkboxes

type CheckboxResult struct {
    Label      string      // Associated label text
    Checked    bool        // Whether the checkbox is selected
    Confidence float64     // Detection confidence (0.0-1.0)
    Page       int         // Page number
    Box        BoundingBox // Checkbox location
    Type       string      // "checkbox", "radio", "bracket", etc.
    GroupName  string      // Name of the group this checkbox belongs to
}

type CheckboxGroupResult struct {
    Name       string           // Group identifier
    Options    []CheckboxResult // All checkboxes in the group
    Selected   []string         // Labels of selected items
    IsMultiple bool             // True if multiple selections are allowed
    Page       int              // Page number where the group appears
    Confidence float64          // Overall group detection confidence
}

Method	Returns
(*CheckboxResult) IsChecked() bool	false on a nil receiver
(*CheckboxResult) HasLabel() bool	A label was associated
(*CheckboxResult) IsHighConfidence() bool	Confidence >= 0.8
(*CheckboxGroupResult) SelectedValue() string	First selection, "" when none
(*CheckboxGroupResult) SelectedValues() []string	Every selection
(*CheckboxGroupResult) HasSelection() bool	Anything selected
(*CheckboxGroupResult) OptionCount() int	Options in the group
(*CheckboxGroupResult) IsYesSelected() bool / IsNoSelected() bool	Yes/No groups
(*CheckboxGroupResult) GetOption(label string) *CheckboxResult	One option by label

On the document:

Method	Returns
GetCheckbox(label string) *CheckboxResult	One checkbox
GetAllCheckboxes() []CheckboxResult	Every checkbox
GetCheckboxGroupResult(name string) *CheckboxGroupResult	One group
GetAllCheckboxGroups() []CheckboxGroupResult	Every group
IsCheckboxChecked(label string) bool	State by label
GetCheckboxValue(label string) string	Value by label
IsYesNoChecked(groupName string) bool	Yes/No group state

When detection misses the box but the OCR carries a marker glyph, the marker family reads the glyph instead:

Method	Returns
CheckedOption(options ...string) string	First option with a checked marker to its left
CheckedOptionMarkers(options []string, checkedChars string) string	Same, with an explicit marker set
CheckedOptionOnPage(options []string, page int64) string	Page-scoped
CheckedOptionNear(anchor string, dir Direction, extent float64, options []string) string	Scoped to a region near an anchor
CheckedOptionNearMarkers(anchor string, dir Direction, extent float64, options []string, checkedChars string) string	Same, with an explicit marker set

DefaultCheckedMarkers is "@®©■•✓✔☑█"; DefaultUncheckedMarkers is "O○□()" and is informational only — the checked set is what matching uses.

Special regions

type SpecialRegionType string

const (
    RegionSignature   SpecialRegionType = "Signature"
    RegionHandwriting SpecialRegionType = "Handwriting"
    RegionBarcode1D   SpecialRegionType = "Barcode1D"
    RegionBarcodeQR   SpecialRegionType = "QRCode"
    RegionBarcode2D   SpecialRegionType = "Barcode2D"
)

type SpecialRegionResult struct {
    Type       SpecialRegionType // Type of special region
    Box        BoundingBox       // Region location
    Page       int               // Page number
    Confidence float64           // Detection confidence (0.0-1.0)
    NearLabel  string            // Nearby label text, e.g. "Sign here"
    OCRText    string            // Any OCR text found in the region
}

Method	Returns
IsSignature() bool, IsHandwriting() bool	Type tests
IsBarcode() bool	True for any of the three barcode types
IsQRCode() bool, Is1DBarcode() bool	Narrow barcode tests
IsHighConfidence() bool, IsMediumConfidence() bool	Confidence bands
HasNearbyLabel() bool	NearLabel is set
String() string	One-line summary

On the document:

Method	Returns
HasSignatures() bool, HasHandwriting() bool, HasBarcodes() bool	Presence
GetSignatures(pageNum int64) []SpecialRegionResult	Signatures on a page
GetAllSignatures() []SpecialRegionResult	Every signature
GetAllHandwriting() []SpecialRegionResult	Every handwriting region
GetAllBarcodes() []SpecialRegionResult	Every barcode
GetAllSpecialRegions() []SpecialRegionResult	Everything detected
GetHighConfidenceSignatures() []special.Region	Signatures above the confidence bar
GetSignaturesOnPage(pageNum int64) []special.Region	Internal-typed, page-scoped
GetHandwritingOnPage(pageNum int64) []special.Region	Internal-typed, page-scoped
GetBarcodesOnPage(pageNum int64) []special.Region	Internal-typed, page-scoped
GetSpecialRegionsByConfidence(minConfidence float64) []special.Region	Internal-typed, filtered

Fonts and typography

Method	Returns
GetFontSize(block text.Block) font.Size	Estimated size for a block
GetLineFontSize(line text.Line) font.Size	Estimated size for a line
GetFontSizeForText(searchText string) float64	Size of the block containing the text
GetBodyFontSize() float64	Median body size
GetHeadingSizes() []float64	Distinct heading sizes
GetBlocksByFontSize(minPt, maxPt float64) []text.Block	Blocks inside a point band
GetHeadingBlocks() []text.Block	Blocks classified as headings
IsHeading(block text.Block) bool	Heading classification
IsHeadingPhrase(phrase string) bool	The phrase sits in a heading
IsHeadingPhraseFirst(phrase string) bool	Only the first match is tested
IsHeadingPhraseInRegion(phrase, regionName string) bool	Heading test inside a named region
IsHeadingPhraseIn(phrase, direction, regionName string, page int64, firstMatchOnly bool) bool	Heading test, fully scoped
IsSmallText(block text.Block) bool	Small or fine print, per the font analysis. false when fonts were not analysed
IsTextBig(searchText string) bool	The block containing the text is taller than average
IsBold(block text.Block) bool	Weight estimate from stroke width
StrokeWidth(block text.Block) float64	Estimated stroke width
TypographyTier(block text.Block) font.Tier	Size tier
IsAllCaps(block text.Block) bool / IsTitleCase(block text.Block) bool	Casing
IsCentered(block text.Block) bool	Horizontally centred on the page within 5%, using Stats.PageWidth
IsCenteredInBox(block text.Block, box geometry.Box, tolerancePct float64) bool	Centred inside a box

Schema-driven extraction

Install schemas with SetSchemas, then extract by name.

Method	Returns
HasForm(name string) bool / HasTable(name string) bool	A schema of that kind is installed
ExtractForm(name string) map[string]any	Field values for a form schema
ExtractFormOnPage(name string, page int64) map[string]any	Page-scoped
ExtractTable(name string) []map[string]any	Rows for a table schema
ExtractTableOnPage(name string, page int64) []map[string]any	Page-scoped
SafeExtractForm(name string) map[string]any	Non-nil empty instead of nil
SafeExtractFormOnPage(name string, page int64) map[string]any	Non-nil empty, page-scoped
SafeExtractTable(name string) []map[string]any	Non-nil empty instead of nil
SafeExtractTableOnPage(name string, page int64) []map[string]any	Non-nil empty, page-scoped
ExtractFormScored(name string) map[string]query.FieldResult	Form values with confidence
ExtractFormScoredOnPage(name string, page int64) map[string]query.FieldResult	Same, page-scoped
DiagnoseForm(name string) []FieldDiagnosis	Why each property did or did not extract

type FieldDiagnosis struct {
    Field          string
    Anchor         string
    ValueFound     bool
    AnchorInScope  bool // matched at the configured tolerance within the schema's page/region
    AnchorAnywhere bool // matched at a looser tolerance anywhere in the document
    Reason         string
}

DiagnoseForm is the tool for a form that extracts nothing: AnchorInScope == false with AnchorAnywhere == true means the scope is wrong, not the anchor.

Classification

type DoctypeSpec struct {
    Name          string
    Keywords      []string
    TitleWeight   float64 // defaults to 0.4 when zero
    HeadingWeight float64 // defaults to 0.3 when zero
    ContentWeight float64 // defaults to 0.3 when zero
}

type ClassifyResult struct {
    Matches        map[string]float64 // document type to confidence
    BestType       string
    BestConfidence float64
}

Method or function	Returns
(*Document) Classify(specs []DoctypeSpec) ClassifyResult	Scores explicit specs
(*Document) ClassifyAs(docTypes ...string) ClassifyResult	Scores registered specs by name; an unknown name scores an empty spec
RegisterDoctype(spec DoctypeSpec)	Package function; appends a spec. Concurrency-safe
RegisteredDoctypes() []DoctypeSpec	DefaultDoctypes first, then registrations in order
ResetDoctypes()	Empties the caller registry
(ClassifyResult) BestMatch() string	BestType
(ClassifyResult) Confidence() float64	BestConfidence
(ClassifyResult) MatchesType(docType string, minConfidence float64) bool	Type scored at or above a threshold
(ClassifyResult) Is(docType string) bool	Type is the best match

DefaultDoctypes ships six domain-neutral specs: invoice, receipt, contract, tax_form, bank_statement, insurance. Vertical types are added with RegisterDoctype.

Section, outline and column results

type SectionResult struct {
    Heading     string          // Section heading text
    Level       int             // Heading level (1=H1, 2=H2, ...)
    Content     string          // All text content in the section
    Subsections []SectionResult // Nested subsections
    Page        int             // Page where the section starts
    Box         BoundingBox     // Section bounding box
}

type OutlineEntryResult struct {
    Text     string               // Heading text
    Level    int                  // Heading level
    Page     int                  // Page number
    Box      BoundingBox          // Heading location
    Children []OutlineEntryResult // Nested headings
}

type ColumnResult struct {
    Index   int         // Column index (0-based, left to right)
    Box     BoundingBox // Column boundaries
    Page    int         // Page number
    Content string      // Text content in the column
}

Method	Returns
(*SectionResult) Text() string	Content
(*SectionResult) AllText() string	Content plus every subsection
(*SectionResult) HasSubsections() bool / SubsectionCount() int	Nesting
(*SectionResult) GetSubsection(heading string) *SectionResult	Child by heading, case-insensitive
(*SectionResult) FindSubsection(text string) *SectionResult	Child by substring, recursive
(*SectionResult) IsEmpty() bool	No content
(*OutlineEntryResult) HasChildren() bool / ChildCount() int	Nesting
(*OutlineEntryResult) GetChild(text string) *OutlineEntryResult	Child by text, case-insensitive
(*OutlineEntryResult) AllHeadings() []string	This heading and every descendant
(*ColumnResult) Text() string / IsEmpty() bool / Width() float64	Column content and geometry

Continue with

• The document model — how the stack is built and what each layer means
• Extracting fields — anchors, chains and scoring in practice
• Tables — table detection and the nil-safe accessors
• Fuzzy matching — edit distances and when to widen them
• The rules bridge — reaching these methods from rule text