schema

type CodeBlockRule struct {
	Lang string `yaml:"lang,omitempty" json:"lang,omitempty" lc:"language identifier (bash, go, python, etc.) - omit for any language"`
	Min  int    `yaml:"min,omitempty" json:"min,omitempty" lc:"minimum required blocks"`
	Max  int    `yaml:"max,omitempty" json:"max,omitempty" lc:"maximum allowed blocks"`
}

type CountConstraint struct {
	Min int `yaml:"min,omitempty" json:"min,omitempty" lc:"minimum occurrences required"`
	Max int `yaml:"max,omitempty" json:"max,omitempty" lc:"maximum occurrences allowed (0 = unlimited)"`
}

type FieldFormat string

type FieldType string

type ForbiddenTextPattern struct {
	// Literal is set when using scalar form (e.g., forbidden_text: "TODO") - substring match
	Literal string `yaml:"-" json:"-"`

	// Pattern is the regex pattern to match (always treated as regex)
	Pattern string `yaml:"pattern,omitempty" json:"pattern,omitempty" lc:"regex pattern that must NOT appear"`
}

type FrontmatterConfig struct {
	// Optional indicates frontmatter block is not required (default: false = required)
	Optional bool `yaml:"optional,omitempty" json:"optional,omitempty" lc:"frontmatter block is not required"`

	// Fields defines the required/optional fields and their constraints
	Fields []FrontmatterField `yaml:"fields,omitempty" json:"fields,omitempty" lc:"field definitions"`
}

type FrontmatterField struct {
	// Name is the field name (required)
	Name string `yaml:"name" json:"name" lc:"field name"`

	// Optional indicates whether this field is not required (default: false = required)
	Optional bool `yaml:"optional,omitempty" json:"optional,omitempty" lc:"field is not required"`

	// Type is the expected type (use FieldType* constants)
	Type FieldType `yaml:"type,omitempty" json:"type,omitempty" lc:"string, number, boolean, array, date"`

	// Format specifies format validation (use FieldFormat* constants)
	Format FieldFormat `yaml:"format,omitempty" json:"format,omitempty" lc:"date, email, or url"`
}

type HeadingPattern struct {
	// Literal is set when using scalar form (e.g., heading: "## Features") - exact match
	Literal string `yaml:"-" json:"-"`

	// Pattern is the heading regex pattern to match (always treated as regex)
	Pattern string `yaml:"pattern,omitempty" json:"pattern,omitempty" lc:"heading regex pattern"`

	// Expr is a boolean expression for dynamic matching (e.g., "slug(filename) == slug(heading)")
	// Available variables: filename (without extension), heading (heading text)
	// Available functions: slug, lower, upper, trim, hasPrefix, hasSuffix, strContains, match, replace, trimPrefix, trimSuffix
	Expr string `yaml:"expr,omitempty" json:"expr,omitempty" lc:"boolean expression for dynamic matching"`
}

type HeadingRules struct {
	// NoSkipLevels ensures heading levels are not skipped (e.g., h1 -> h3 without h2)
	NoSkipLevels bool `yaml:"no_skip_levels,omitempty" json:"no_skip_levels,omitempty" lc:"disallow skipping levels (e.g., h1 -> h3)"`

	// Unique ensures all headings in the document are unique
	Unique bool `yaml:"unique,omitempty" json:"unique,omitempty" lc:"all headings must be unique"`

	// UniquePerLevel ensures headings are unique within the same level
	UniquePerLevel bool `yaml:"unique_per_level,omitempty" json:"unique_per_level,omitempty" lc:"headings unique within same level"`

	// MaxDepth limits the maximum heading depth (1-6, where 1 is h1)
	MaxDepth int `yaml:"max_depth,omitempty" json:"max_depth,omitempty" lc:"maximum heading depth (1-6)"`
}

type ImageRule struct {
	Min        int      `yaml:"min,omitempty" json:"min,omitempty" lc:"minimum required images"`
	Max        int      `yaml:"max,omitempty" json:"max,omitempty" lc:"maximum allowed images"`
	RequireAlt bool     `yaml:"require_alt,omitempty" json:"require_alt,omitempty" lc:"require alt text"`
	Formats    []string `yaml:"formats,omitempty" json:"formats,omitempty" lc:"allowed formats (png, jpg, gif, etc.)"`
}

type LinkRule struct {
	// ValidateInternal validates anchor links (#section-name)
	ValidateInternal bool `yaml:"validate_internal,omitempty" json:"validate_internal,omitempty" lc:"check anchor links (#section-name)"`

	// ValidateFiles validates relative file links (./other.md)
	ValidateFiles bool `yaml:"validate_files,omitempty" json:"validate_files,omitempty" lc:"check relative file links (./other.md)"`

	// ValidateExternal validates external URLs (http/https)
	ValidateExternal bool `yaml:"validate_external,omitempty" json:"validate_external,omitempty" lc:"check external URLs (http/https)"`

	// ExternalTimeout is the timeout in seconds for external URL checks (default: 10)
	ExternalTimeout int `yaml:"external_timeout,omitempty" json:"external_timeout,omitempty" lc:"timeout in seconds for external URL checks"`

	// AllowedDomains restricts external links to these domains only
	AllowedDomains []string `yaml:"allowed_domains,omitempty" json:"allowed_domains,omitempty" lc:"restrict external links to these domains"`

	// BlockedDomains blocks external links to these domains
	BlockedDomains []string `yaml:"blocked_domains,omitempty" json:"blocked_domains,omitempty" lc:"block links to these domains"`
}

type ListRule struct {
	Min      int      `yaml:"min,omitempty" json:"min,omitempty" lc:"minimum required lists"`
	Max      int      `yaml:"max,omitempty" json:"max,omitempty" lc:"maximum allowed lists"`
	Type     ListType `yaml:"type,omitempty" json:"type,omitempty" lc:"ordered, unordered, or empty for any"`
	MinItems int      `yaml:"min_items,omitempty" json:"min_items,omitempty" lc:"minimum items per list"`
}

type ListType string

type RequiredTextPattern struct {
	// Literal is set when using scalar form (e.g., required_text: "text") - substring match
	Literal string `yaml:"-" json:"-"`

	// Pattern is the regex pattern to match (always treated as regex)
	Pattern string `yaml:"pattern,omitempty" json:"pattern,omitempty" lc:"regex pattern to match"`
}

type Schema struct {
	// Document structure with embedded section rules
	Structure []StructureElement `` /* 139-byte string literal not displayed */

	// Global link validation rules
	Links *LinkRule `yaml:"links,omitempty" json:"links,omitempty" hc:"Global link validation settings"`

	// Global heading validation rules
	HeadingRules *HeadingRules `yaml:"heading_rules,omitempty" json:"heading_rules,omitempty" hc:"Global heading validation rules"`

	// Frontmatter validation rules
	Frontmatter *FrontmatterConfig `yaml:"frontmatter,omitempty" json:"frontmatter,omitempty" hc:"YAML frontmatter validation"`
}

type SectionRules struct {
	// Required text/substrings within the section
	RequiredText []RequiredTextPattern `yaml:"required_text,omitempty" json:"required_text,omitempty" lc:"text that must appear in this section"`

	// Forbidden text patterns that must NOT appear
	ForbiddenText []ForbiddenTextPattern `yaml:"forbidden_text,omitempty" json:"forbidden_text,omitempty" lc:"text that must NOT appear"`

	// Code block requirements within this section
	CodeBlocks []CodeBlockRule `yaml:"code_blocks,omitempty" json:"code_blocks,omitempty" lc:"code block requirements"`

	// Image requirements within this section
	Images []ImageRule `yaml:"images,omitempty" json:"images,omitempty" lc:"image requirements"`

	// Table requirements within this section
	Tables []TableRule `yaml:"tables,omitempty" json:"tables,omitempty" lc:"table requirements"`

	// List requirements within this section
	Lists []ListRule `yaml:"lists,omitempty" json:"lists,omitempty" lc:"list requirements"`

	// Word count requirements for the section
	WordCount *WordCountRule `yaml:"word_count,omitempty" json:"word_count,omitempty" lc:"word count constraints"`
}

type StructureElement struct {
	// Heading pattern (string or {pattern: "...", regex: true})
	Heading HeadingPattern `yaml:"heading,omitempty" json:"heading,omitempty"`

	// Description is guidance text shown in generated output as an HTML comment
	Description string `yaml:"description,omitempty" json:"description,omitempty" lc:"section description shown in generated output"`

	// Optional element flag
	Optional bool `yaml:"optional,omitempty" json:"optional,omitempty" lc:"section is not required"`

	// Count defines how many times this element can match (default: exactly once)
	// When specified, takes precedence over Optional
	Count *CountConstraint `yaml:"count,omitempty" json:"count,omitempty" lc:"occurrence constraints {min, max}"`

	// Severity level for violations (error, warning, info). Default: error
	Severity string `` /* 147-byte string literal not displayed */

	// AllowAdditional permits extra subsections not defined in children
	AllowAdditional bool `yaml:"allow_additional,omitempty" json:"allow_additional,omitempty" lc:"allow extra subsections not in schema"`

	// Hierarchical children elements
	Children []StructureElement `yaml:"children,omitempty" json:"children,omitempty" lc:"nested subsections"`

	// Embedded section rules for validation within this element's scope
	*SectionRules `yaml:",inline"`
}

type TableRule struct {
	Min             int      `yaml:"min,omitempty" json:"min,omitempty" lc:"minimum required tables"`
	Max             int      `yaml:"max,omitempty" json:"max,omitempty" lc:"maximum allowed tables"`
	MinColumns      int      `yaml:"min_columns,omitempty" json:"min_columns,omitempty" lc:"minimum columns per table"`
	RequiredHeaders []string `yaml:"required_headers,omitempty" json:"required_headers,omitempty" lc:"headers that must exist"`
}

type WordCountRule struct {
	Min int `yaml:"min,omitempty" json:"min,omitempty" lc:"minimum words"`
	Max int `yaml:"max,omitempty" json:"max,omitempty" lc:"maximum words"`
}