validator

type CancelExactlyOneRule struct{}

type Config struct {
	Strict     bool   // Treat selected warnings as errors; apply stricter SCXML rules
	DataModel  string // Optional datamodel context (ecmascript, xpath, null, starlark)
	SourceName string // Optional source name for reporting

	// RecursiveInvoke enables recursive validation of invoked SCXML files.
	// When true, the validator will attempt to load and validate any SCXML files
	// referenced in <invoke type="scxml" src="..."> elements.
	RecursiveInvoke bool

	// InvokeBasePath is the base directory to resolve relative paths in invoke src attributes.
	// If empty, paths are resolved relative to the current working directory.
	InvokeBasePath string

	// SchemaBasePath is the base directory to resolve relative schema paths in xmlns declarations.
	// If empty, defaults to InvokeBasePath or current working directory.
	SchemaBasePath string

	// SemanticRules allows injection of custom semantic validators.
	// If nil, DefaultSemanticRules() is used.
	// Set to empty slice to disable semantic validation.
	SemanticRules []SemanticRule

	// SchemaLoaders allows injection of custom XSD schema loaders.
	// Loaders are tried in order - more specific patterns should come first.
	// If nil, default loaders are used.
	SchemaLoaders []SchemaLoaderSpec

	// JSONSchemas stores loaded JSON schemas keyed by namespace prefix.
	// These are loaded from schema:* attributes on the root element.
	// Example: schema:user="file://schema.json" -> JSONSchemas["user"] = loaded schema
	JSONSchemas map[string]*jsonschema.Schema
	// contains filtered or unexported fields
}

type Diagnostic struct {
	Severity  Severity  `json:"severity"`
	Code      string    `json:"code"`
	Message   string    `json:"message"`
	Position  Position  `json:"position"`
	Tag       string    `json:"tag"`
	Attribute string    `json:"attribute,omitempty"`
	SpecRef   string    `json:"spec_ref,omitempty"`
	Hints     []string  `json:"hints,omitempty"`
	Related   []Related `json:"related,omitempty"`
}

type DonedataContentParamExclusionRule struct{}

type EventDescriptorRule struct{}

type HistoryShallowTargetRule struct{}

type IDTokenRule struct{}

type InitialOneTransitionRule struct{}

type InitialTargetDescendantRule struct{}

type InitialTransitionConstraintsRule struct{}

type InvokeSrcExclusivityRule struct{}

type JSONConfig struct{}

type JSONReporter struct {
	// contains filtered or unexported fields
}

type ParamNameAndXorRule struct{}

type Position struct {
	File   string `json:"file"`
	Line   int    `json:"line"`
	Column int    `json:"column"`
	Offset int64  `json:"offset"`
}

type PrettyConfig struct {
	Color           bool
	ContextBefore   int
	ContextAfter    int
	ShowFullElement bool
	MaxElementLines int // 0 = unlimited
}

type PrettyReporter struct {
	// contains filtered or unexported fields
}

type Related struct {
	Label    string   `json:"label"`
	Position Position `json:"position"`
}

type Result struct {
	Diagnostics []Diagnostic `json:"diagnostics"`
}

type SchemaLoaderSpec struct {
	Pattern string               // Regex pattern to match namespace URIs
	Loader  xsd.SchemaLoaderFunc // Function to load the schema
}

type SchemaReference struct {
	IsInline  bool   // true if inline JSON schema, false if namespace pointer
	Namespace string // namespace prefix (e.g., "user" from "user:/definitions/User")
	Pointer   string // JSON pointer path (e.g., "/definitions/User")
	Inline    string // inline JSON schema string if IsInline is true
}

type SemanticRule interface {
	// Name returns the diagnostic code for this rule (e.g., "E301")
	Name() string

	// Validate checks the rule against a document and returns diagnostics
	Validate(doc xmldom.Document, config Config) []Diagnostic
}

type SendContentEventExclusionRule struct{}

type SendNamelistContentExclusionRule struct{}

type Severity string

type StateDeadlockRule struct{}

type StateInitialAtomicRule struct{}

type StateInitialConflictRule struct{}

type TransitionAtLeastOneRule struct{}

type UnconditionalTransitionCycleRule struct{}

type Validator struct {
	// contains filtered or unexported fields
}