props

type Barcode struct {
	// Left is the space between the left cell boundary to the barcode, if center is false.
	Left float64
	// Top is space between the upper cell limit to the barcode, if center is false.
	Top float64
	// Percent is how much the barcode will occupy the cell,
	// ex 100%: The barcode will fulfill the entire cell
	// ex 50%: The greater side from the barcode will have half the size of the cell.
	Percent float64
	// Proportion is the proportion between size of the barcode.
	// Ex: 16x9, 4x3...
	Proportion Proportion
	// Center define that the barcode will be vertically and horizontally centralized.
	Center bool
	// Type represents the barcode type. Default: code128
	Type barcode.Type
}

type Cell struct {
	// BackgroundColor defines which color will be applied to a cell.
	// Default: nil
	BackgroundColor *Color
	// BorderColor defines which color will be applied to a border cell
	// Default: nil
	BorderColor *Color
	// BorderType defines which kind of border will be applied to a cell.
	// Default: border.None
	BorderType border.Type
	// BorderThickness defines the border thickness applied to a cell.
	// Default: 0.2
	BorderThickness float64
	// LineStyle defines which line style will be applied to a cell.
	// Default: Solid
	LineStyle linestyle.Type

	// Per-side padding (mm). Applied by components to shift content inward.
	PaddingTop    float64
	PaddingRight  float64
	PaddingBottom float64
	PaddingLeft   float64

	// Per-side margin (mm). Applied by styled rows and columns to inset the
	// painted cell box and its content from the allocated grid cell.
	MarginTop    float64
	MarginRight  float64
	MarginBottom float64
	MarginLeft   float64

	// Per-side border colors (nil = no override; falls back to BorderColor).
	BorderTopColor    *Color
	BorderRightColor  *Color
	BorderBottomColor *Color
	BorderLeftColor   *Color

	// Per-side border thickness (0 = no border for that side).
	// When any of these is non-zero the PerSideBorderStyler activates and
	// draws raw Line calls instead of CellFormat borders.
	BorderTopThickness    float64
	BorderRightThickness  float64
	BorderBottomThickness float64
	BorderLeftThickness   float64

	// Per-side border line style ("solid", "dashed", "dotted"). Empty = solid.
	BorderTopStyle    linestyle.Type
	BorderRightStyle  linestyle.Type
	BorderBottomStyle linestyle.Type
	BorderLeftStyle   linestyle.Type

	// BackgroundGradient, when non-nil, paints a gradient behind the cell
	// (overrides BackgroundColor when both are set).
	BackgroundGradient *Gradient

	// BackgroundImage, when non-nil, paints an image behind the cell content.
	BackgroundImage *CellBackgroundImage

	// BoxShadow holds the shadows to paint behind the cell (up to 4).
	BoxShadow []Shadow

	// Outline fields. Outline is drawn OUTSIDE the cell box (does not affect layout).
	OutlineWidth  float64
	OutlineStyle  linestyle.Type
	OutlineColor  *Color
	OutlineOffset float64 // mm; positive = further out, negative = inside border

	// BorderRadius is the uniform corner radius in mm. When per-corner radii
	// below are set, they override this uniform value for that corner.
	// When any radius is set, the borderRadiusStyler owns the entire border
	// render and per-side stroke thicknesses are averaged into a single width.
	BorderRadius float64

	// Per-corner border radius (mm). 0 = inherit from BorderRadius.
	BorderRadiusTopLeft     float64
	BorderRadiusTopRight    float64
	BorderRadiusBottomLeft  float64
	BorderRadiusBottomRight float64
}

type CellBackgroundImage struct {
	Bytes     []byte
	Extension extension.Type
	Rect      Rect
	Size      string
	Position  string
	Repeat    string
}

type Checkbox struct {
	// Checked defines whether the checkbox is marked.
	Checked bool
	// Top is the amount of space between the upper cell limit and the checkbox.
	Top float64
	// Left is the amount of space between the left cell boundary and the checkbox.
	Left float64
	// Size is the size of the checkbox square in mm.
	Size float64
}

type Color struct {
	// Red is the amount of red
	Red int
	// Green is the amount of red
	Green int
	// Blue is the amount of red
	Blue int
	// Alpha is the translucency in [0, 1]; nil = fully opaque (default).
	Alpha *float64
}

type Font struct {
	// Family of the text, ex: constf.Arial, helvetica and etc.
	Family string
	// Style of the text, ex: constf.Normal, bold and etc.
	Style fontstyle.Type
	// Size of the text.
	Size float64
	// Color define the font color.
	Color *Color
}

type Gradient struct {
	Kind     GradientKind
	AngleDeg float64        // linear angle or conic starting angle
	Circle   bool           // radial only
	CX, CY   float64        // radial/conic centre (0–1 fractions)
	Stops    []GradientStop // at least 2, positions in [0,1]
}

type GradientKind int

type GradientStop struct {
	Color    Color
	Position float64
}

type Line struct {
	// Color define the line color.
	Color *Color
	// Style define the line style (solid or dashed).
	Style linestyle.Type
	// Thickness define the line thicknesl.
	Thickness float64
	// Orientation define if line would be horizontal or vertical.
	Orientation orientation.Type
	// OffsetPercent define where the line would be placed, 0 is the start of cell, 50 the middle and 100 the end.
	OffsetPercent float64
	// SizePercent define the size of the line inside cell.
	SizePercent float64
}

type PageNumber struct {
	// Pattern is the string pattern which will be used to apply the page count component.
	Pattern string
	// Place defines where the page count component will be placed.
	Place Place
	// Family defines which font family will be applied to page count.
	Family string
	// Style defines which font style will be applied to page count.
	Style fontstyle.Type
	// Size defines which font size will be applied to page count.
	Size float64
	// Color defines which will be applied to page count.
	Color *Color
}

type Place string

type Proportion struct {
	// Width from the rectangle: Barcode, image and etc.
	Width float64
	// Height from the rectangle: Barcode, image and etc.
	Height float64
}

type Rect struct {
	// Left is the space between the left cell boundary to the rectangle, if center is false.
	Left float64
	// Top is space between the upper cell limit to the barcode, if center is false.
	Top float64
	// Percent is how much the rectangle will occupy the cell,
	// ex 100%: The rectangle will fulfill the entire cell
	// ex 50%: The greater side from the rectangle will have half the size of the cell.
	Percent float64
	// indicate whether only the width should be used as a reference to calculate the component size, disregarding the height
	// ex true: The component will be scaled only based on the available width, disregarding the available height
	JustReferenceWidth bool
	// Center define that the barcode will be vertically and horizontally centralized.
	Center bool
	// ObjectFit defines how an image should fit into its content box.
	ObjectFit string
	// ObjectPosition defines the image alignment inside its content box.
	ObjectPosition string
}

type RichImage struct {
	Bytes          []byte
	Extension      extension.Type
	Width          float64
	Height         float64
	Alt            string
	ObjectFit      string
	ObjectPosition string
}

type RichRun struct {
	Text          string
	Image         *RichImage
	Family        string
	Style         fontstyle.Type
	Size          float64
	SizeScale     float64 // multiplier applied after Size/default font resolution; 0 = unchanged
	Color         *Color
	Underline     bool
	Strikethrough bool
	Hyperlink     *string
	VerticalAlign string // "baseline" | "sub" | "super"
	Hidden        bool   // preserves layout but skips painting for CSS visibility:hidden

	// LetterSpacing is extra character spacing in mm (0 = default).
	LetterSpacing float64
	// Background, when non-nil, paints a filled rectangle behind the run before
	// drawing the text. Used by HTML <mark>, <kbd>, inline <code>.
	Background *Color
	// LocalAnchor, when non-empty, makes the run an internal PDF link target
	// to the named destination (registered via id="…" on a block element).
	// Takes precedence over Hyperlink.
	LocalAnchor string

	// TextShadow, when non-nil, draws a shadow behind the run text. Only the
	// first shadow is stored here for compatibility. TextShadows stores the full
	// CSS comma-separated list when available.
	TextShadow *Shadow
	// TextShadows, when non-empty, draws every shadow behind the run text in
	// order before the normal text is painted.
	TextShadows []Shadow
}

type RichText struct {
	Top               float64
	Bottom            float64
	Left              float64
	Right             float64
	Align             align.Type
	LineHeight        float64
	BreakLineStrategy breakline.Strategy
	FirstLineIndent   float64
	WhiteSpace        string

	// AnchorResolver, when non-nil, is called with a LocalAnchor name to
	// obtain the PDF link ID for per-run internal anchor rectangles. It is set
	// at render time by richtext.RichText.Render when the provider implements
	// core.LinkProvider and the component was built with an anchor registry.
	AnchorResolver func(name string) int
}

type Shadow struct {
	OffsetX    float64 // mm
	OffsetY    float64 // mm
	BlurRadius float64 // mm (approximated as multi-rect overlay)
	Spread     float64 // mm (expands rect uniformly before blur)
	Color      *Color  // nil = use default black
	Inset      bool    // draw inside cell rather than behind it
}

type Signature struct {
	// FontFamily of the text, ex: consts.Arial, helvetica and etc.
	FontFamily string
	// FontStyle of the text, ex: consts.Normal, bold and etc.
	FontStyle fontstyle.Type
	// FontSize of the text.
	FontSize float64
	// FontColor define the font color.
	FontColor *Color
	// LineColor define the line color.
	LineColor *Color
	// LineStyle define the line style (solid or dashed).
	LineStyle linestyle.Type
	// LineThickness define the line thickness.
	LineThickness float64

	SafePadding float64
}

type Text struct {
	// Top is the amount of space between the upper cell limit and the text.
	Top float64
	// Bottom is the amount of space between the lower cell limit and the text. (Used by auto row only)
	Bottom float64
	// Left is the minimal amount of space between the left cell boundary and the text.
	Left float64
	// Right is the minimal amount of space between the right cell boundary and the text.
	Right float64
	// Family of the text, ex: consts.Arial, helvetica and etc.
	Family string
	// Style of the text, ex: consts.Normal, bold and etc.
	Style fontstyle.Type
	// Size of the text.
	Size float64
	// Align of the text.
	Align align.Type
	// BreakLineStrategy define the break line strategy.
	BreakLineStrategy breakline.Strategy
	// VerticalPadding define an additional space between linet.
	VerticalPadding float64
	// Color define the font style color.
	Color *Color
	// Hyperlink define a link to be opened when the text is clicked.
	Hyperlink *string
}