v3

type AcceptsRuleResults interface {
	AddRuleFunctionResult(result *RuleFunctionResult)
	GetRuleFunctionResults() []*RuleFunctionResult
}

type BuildError struct {
	Error         error
	SchemaProxy   *base.SchemaProxy
	DrSchemaProxy *SchemaProxy
}

type Callback struct {
	Value      *v3.Callback
	Expression *orderedmap.Map[string, *PathItem]
	Foundation
}

type ChangeSummary struct {
	Additions     int `json:"additions"`
	Modifications int `json:"modifications"`
	Removals      int `json:"removals"`
	Breaking      int `json:"breaking"`
	Total         int `json:"total"`
}

type ChildChangeSummary struct {
	Label   string         `json:"label"`
	Type    string         `json:"type"`
	IdHash  string         `json:"idHash"`
	NodeId  string         `json:"nodeId"`
	Changes *ChangeSummary `json:"changes"`
}

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

type Companion interface {
	Travel(ctx context.Context, tardis Tardis)
}

type Components struct {
	Value           *v3.Components
	Schemas         *orderedmap.Map[string, *SchemaProxy]
	Responses       *orderedmap.Map[string, *Response]
	Parameters      *orderedmap.Map[string, *Parameter]
	Examples        *orderedmap.Map[string, *Example]
	RequestBodies   *orderedmap.Map[string, *RequestBody]
	Headers         *orderedmap.Map[string, *Header]
	SecuritySchemes *orderedmap.Map[string, *SecurityScheme]
	Links           *orderedmap.Map[string, *Link]
	Callbacks       *orderedmap.Map[string, *Callback]
	PathItems       *orderedmap.Map[string, *PathItem]
	Foundation
}

type Contact struct {
	Value *base.Contact `json:"contact,omitempty" yaml:"contact,omitempty"`
	Foundation
}

type ContextKey string

type Discriminator struct {
	Value *base.Discriminator
	Foundation
}

type Doctor interface {
	LocateModelsByKeyAndValue(key, value *yaml.Node) ([]Foundational, error)
	LocateModel(node *yaml.Node) ([]Foundational, error)
	LocateModelByLine(line int) ([]Foundational, error)
}

type Document struct {
	Document     *v3.Document
	Info         *Info
	Servers      []*Server
	Paths        *Paths
	Components   *Components
	Security     []*SecurityRequirement
	Tags         []*Tag
	ExternalDocs *ExternalDoc
	Webhooks     *orderedmap.Map[string, *PathItem]
	Foundation
}

type DrContext struct {
	SchemaChan        chan *WalkedSchema
	ObjectChan        chan any
	SkippedSchemaChan chan *WalkedSchema
	ParameterChan     chan *WalkedParam
	HeaderChan        chan *WalkedHeader
	MediaTypeChan     chan *WalkedMediaType
	ErrorChan         chan *BuildError
	NodeChan          chan *Node
	EdgeChan          chan *Edge
	Index             *index.SpecIndex
	Rolodex           *index.Rolodex
	V3Document        *v3.Document
	BuildGraph        bool
	RenderChanges     bool
	UseSchemaCache    bool
	SyncWalk          bool      // When true, walk everything synchronously (no goroutines)
	WalkPool          *WalkPool // General bounded worker pool for all walk operations
	// Deprecated: schema subtrees are walked inline before cache publication.
	// This field is retained only for source compatibility with callers that
	// constructed DrContext directly.
	SchemaPool *SchemaWalkPool
	// Deprecated: pooled walking is the default whenever SyncWalk is false.
	// This field is retained only for source compatibility.
	PooledWalk         bool
	DeterministicPaths bool // When true, component objects return definition-site paths
	SchemaCache        *sync.Map
	CanonicalPathCache *sync.Map // Maps *yaml.Node pointer -> canonical JSONPath (definition site)
	HashCache          *HashCache
	// Deprecated: string interning was removed from the walker. This field is
	// retained only for source compatibility.
	StringCache      *sync.Map
	StorageRoot      string
	WorkingDirectory string
	Logger           *slog.Logger

	// CanonicalPathsApplied tracks canonical schemas whose subtrees have had
	// canonical cache paths applied during this walk, so repeated cache hits
	// skip the idempotent full-subtree traversal. A pointer so DrContext
	// copies (WalkContextForRef) share the set; nil simply disables the guard.
	CanonicalPathsApplied *sync.Map

	// CircularRefs caches circular-reference lookups as sets so reference
	// walks avoid re-assembling slices per $ref. A pointer so DrContext
	// copies share it; nil falls back to scanning the index slices directly.
	CircularRefs *CircularRefSets
}

type DynamicValue[A, R, S, E any] struct {
	Value *base.DynamicValue[A, R]
	A     S
	B     E
	Foundation
}

type Edge struct {
	Id      string   `json:"id"`
	Sources []string `json:"sources"`
	Targets []string `json:"targets"`
	Poly    string   `json:"poly,omitempty"`
	Ref     string   `json:"ref"`

	// TargetLine carries an unresolved reference target as a source line
	// number during the walk; it is resolved to a node id (Targets[0]) or the
	// edge is dropped before edges are published. Never serialized.
	TargetLine int `json:"-"`
}

type Encoding struct {
	Value   *v3.Encoding
	Headers *orderedmap.Map[string, *Header]
	Foundation
}

type Example struct {
	Value *base.Example
	Foundation
}

type ExternalDoc struct {
	Value *base.ExternalDoc
	Foundation
}

type Foundation struct {
	PathSegment  string
	InstanceType string
	IsIndexed    bool
	Index        *int
	Key          string
	PolyType     string
	Parent       any
	NodeParent   any
	RuleResults  []*RuleFunctionResult
	JSONPath     string
	Mutex        sync.RWMutex
	// Deprecated: retained only for source compatibility with direct struct
	// users. Locking this mutex no longer synchronizes PathSegment; use
	// GetPathSegment and SetPathSegment instead.
	PathSegmentMutex sync.RWMutex
	JSONPathOnce     sync.Once
	Node             *Node
	NodeReference    *Node // if the chain was broken, keep a reference
	Edges            []*Edge
	KeyNode          *yaml.Node
	ValueNode        *yaml.Node
	Changes          []*NodeChange
	CacheSplit       bool
}

type Foundational interface {
	GetParent() Foundational
	GetNodeParent() Foundational
	GetPathSegment() string
	GetKeyValue() string
	GetIndexValue() *int
	GenerateJSONPath() string
	GenerateJSONPathWithLevel(level int) string
	GetRoot() Foundational
	SetNode(node *Node)
	AddEdge(edge *Edge)
	GetNode() *Node
	GetRefNode() *Node
	GetEdges() []*Edge
	GetKeyNode() *yaml.Node
	GetValueNode() *yaml.Node
	GetInstanceType() string
	SetInstanceType(instanceType string)
	GetChanges() []*NodeChange
	AddChanges(changes []*NodeChange)
	AddChange(changes *NodeChange)
}

type HasIndex interface {
	GetIndex() *index.SpecIndex
}

type HasSize interface {
	GetSize() (height, width int)
}

type HasValue interface {
	GetValue() any
}

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

type Header struct {
	Value    *v3.Header
	Schema   *SchemaProxy
	Examples *orderedmap.Map[string, *Example]
	Content  *orderedmap.Map[string, *MediaType]
	Foundation
}

type Info struct {
	Value   *base.Info
	Contact *Contact
	License *License
	Foundation
}

type IsObjectReference interface {
	IsReference() bool
	GetReference() string
	GetReferenceNode() *yaml.Node
}

type License struct {
	Value *base.License
	Foundation
}

type Link struct {
	Value  *v3.Link
	Server *Server
	Foundation
}

type MediaType struct {
	Value       *v3.MediaType
	SchemaProxy *SchemaProxy
	Examples    *orderedmap.Map[string, *Example]
	Encoding    *orderedmap.Map[string, *Encoding]
	Foundation
}

type Node struct {
	Value                *yaml.Node             `json:"-"`
	Id                   string                 `json:"id"`
	IdHash               string                 `json:"idHash,omitempty"`
	ParentId             string                 `json:"parentId"`
	Type                 string                 `json:"type"`
	Label                string                 `json:"label"`
	Width                int                    `json:"width"`
	Height               int                    `json:"height"`
	Children             []*Node                `json:"nodes,omitempty"`
	IsArray              bool                   `json:"isArray,omitempty"`
	IsPoly               bool                   `json:"isPoly,omitempty"`
	PolyType             string                 `json:"polyType,omitempty"`
	PropertyCount        int                    `json:"propertyCount,omitempty"`
	ArrayIndex           int                    `json:"arrayIndex,omitempty"`
	ArrayValues          int                    `json:"arrayValues,omitempty"`
	Extensions           int                    `json:"extensions,omitempty"`
	Hash                 string                 `json:"hash,omitempty"`
	OriginLocation       string                 `json:"originLocation,omitempty"`
	Origin               *index.NodeOrigin      `json:"nodeOrigin,omitempty"`
	KeyLine              int                    `json:"-"`
	ValueLine            int                    `json:"valueLine"`
	Instance             any                    `json:"instance"`
	DrInstance           any                    `json:"-"`
	Changes              []what_changed.Changed `json:"-"`
	RenderedChanges      []*model.Change        `json:"timeline,omitempty"`
	CleanedChanged       []*model.Change        `json:"cleanedChanges,omitempty"`
	SubtreeChanges       *ChangeSummary         `json:"-"`
	ChildChangeSummaries []*ChildChangeSummary  `json:"-"`
	RenderProps          bool                   `json:"-"`
	RenderChanges        bool                   `json:"-"`
	RenderProblems       bool                   `json:"-"`
	RenderProblemsAsIds  bool                   `json:"-"` // modified design to stop embedding violations in nodes, uses lookup now.
	ViolationIdMap       map[string]string      `json:"-"`
	Mutex                sync.RWMutex           `json:"-"`
	// contains filtered or unexported fields
}

type NodeChange struct {
	Id         string               `json:"id,omitempty"`
	IdHash     string               `json:"idHash,omitempty"`
	Type       string               `json:"type,omitempty"`
	Label      string               `json:"label,omitempty"`
	Path       string               `json:"path,omitempty"`
	Children   []*Node              `json:"nodes,omitempty"`
	ArrayIndex int                  `json:"arrayIndex,omitempty"`
	Changes    what_changed.Changed `json:"timeline,omitempty"`
	Mutex      sync.RWMutex         `json:"-"`
}

type NodeChangeable interface {
	GetType() string
	GetLabel() string
	GetHash() string
	GetPath() string
}

type OAuthFlow struct {
	Value *v3.OAuthFlow
	Foundation
}

type OAuthFlows struct {
	Value             *v3.OAuthFlows
	Implicit          *OAuthFlow
	Password          *OAuthFlow
	ClientCredentials *OAuthFlow
	AuthorizationCode *OAuthFlow
	Device            *OAuthFlow
	Foundation
}

type ObjectReference struct {
	Reference string
	Node      *yaml.Node
	Foundation
}

type Operation struct {
	Value        *v3.Operation
	ExternalDocs *ExternalDoc
	Parameters   []*Parameter
	RequestBody  *RequestBody
	Responses    *Responses
	Callbacks    *orderedmap.Map[string, *Callback]
	Security     []*SecurityRequirement
	Servers      []*Server
	Tags         *Foundation
	Foundation
}

type Parameter struct {
	Value       *v3.Parameter
	SchemaProxy *SchemaProxy
	Examples    *orderedmap.Map[string, *Example]
	Content     *orderedmap.Map[string, *MediaType]
	Foundation
}

type PathItem struct {
	Value      *v3.PathItem
	Get        *Operation
	Put        *Operation
	Post       *Operation
	Delete     *Operation
	Options    *Operation
	Head       *Operation
	Patch      *Operation
	Trace      *Operation
	Servers    []*Server
	Parameters []*Parameter
	Foundation
}

type Paths struct {
	Value     *v3.Paths
	PathItems *orderedmap.Map[string, *PathItem]
	Foundation
}

type RequestBody struct {
	Value   *v3.RequestBody
	Content *orderedmap.Map[string, *MediaType]
	Foundation
}

type Response struct {
	Value   *v3.Response
	Headers *orderedmap.Map[string, *Header]
	Content *orderedmap.Map[string, *MediaType]
	Links   *orderedmap.Map[string, *Link]
	Foundation
}

type Responses struct {
	Value   *v3.Responses
	Codes   *orderedmap.Map[string, *Response]
	Default *Response
	Foundation
}

type Rule struct {
	Id           string        `json:"id,omitempty" yaml:"id,omitempty"`
	Description  string        `json:"description,omitempty" yaml:"description,omitempty"`
	Message      string        `json:"message,omitempty" yaml:"message,omitempty"`
	Recommended  bool          `json:"recommended,omitempty" yaml:"recommended,omitempty"`
	Type         string        `json:"type,omitempty" yaml:"type,omitempty"`
	Severity     string        `json:"severity,omitempty" yaml:"severity,omitempty"`
	RuleCategory *RuleCategory `json:"category,omitempty" yaml:"category,omitempty"`
	HowToFix     string        `json:"howToFix,omitempty" yaml:"howToFix,omitempty"`
}

type RuleCategory struct {
	Id          string `json:"id" yaml:"id"`
	Name        string `json:"name" yaml:"name"`
	Description string `json:"description" yaml:"description"`
}

type RuleFunctionResult struct {
	Message      string            `json:"message" yaml:"message"`
	Path         string            `json:"path" yaml:"path"`
	RuleId       string            `json:"ruleId" yaml:"ruleId"`
	RuleSeverity string            `json:"ruleSeverity" yaml:"ruleSeverity"`
	Origin       *index.NodeOrigin `json:"origin,omitempty" yaml:"origin,omitempty"`
	Rule         *Rule             `json:"-" yaml:"-"`
	StartNode    *yaml.Node        `json:"-" yaml:"-"`
	EndNode      *yaml.Node        `json:"-" yaml:"-"`
	ParentObject any               `json:"-" yaml:"-"`
}

type Schema struct {
	Name                  string
	Value                 *base.Schema
	Hash                  string
	AllOf                 []*SchemaProxy
	OneOf                 []*SchemaProxy
	AnyOf                 []*SchemaProxy
	PrefixItems           []*SchemaProxy
	Discriminator         *Discriminator
	Contains              *SchemaProxy
	If                    *SchemaProxy
	Else                  *SchemaProxy
	Then                  *SchemaProxy
	DependentSchemas      *orderedmap.Map[string, *SchemaProxy]
	PatternProperties     *orderedmap.Map[string, *SchemaProxy]
	PropertyNames         *SchemaProxy
	UnevaluatedItems      *SchemaProxy
	UnevaluatedProperties *DynamicValue[*base.SchemaProxy, bool, *SchemaProxy, bool]
	Items                 *DynamicValue[*base.SchemaProxy, bool, *SchemaProxy, bool]
	Not                   *SchemaProxy
	Properties            *orderedmap.Map[string, *SchemaProxy]
	AdditionalProperties  *DynamicValue[*base.SchemaProxy, bool, *SchemaProxy, bool]
	XML                   *XML
	ExternalDocs          *ExternalDoc
	// Definition points at the canonical schema for render-cache aliases.
	// It remains exported for compatibility; external callers should treat it
	// as read-only and use the alias-safe *ForRead helpers instead of assigning
	// it directly.
	// Alias child fields are populated lazily via the *ForRead helpers. The
	// canonical schema is treated as immutable after cache publication; alias
	// Hash and Walked values are snapshots from that build phase.
	Definition *Schema
	// Walked remains true for render-cache aliases because their canonical
	// definition has already been walked.
	Walked bool

	Foundation
	// contains filtered or unexported fields
}

type SchemaProxy struct {
	Value  *base.SchemaProxy
	Schema *Schema
	Foundation
}

type SecurityRequirement struct {
	Value *base.SecurityRequirement
	Foundation
}

type SecurityScheme struct {
	Value *v3.SecurityScheme
	Flows *OAuthFlows
	Foundation
}

type Server struct {
	Value     *v3.Server
	Variables *orderedmap.Map[string, *ServerVariable]
	Foundation
}

type ServerVariable struct {
	Value *v3.ServerVariable
	Foundation
}

type Tag struct {
	Value        *libopenapibase.Tag
	ExternalDocs *ExternalDoc
	Foundation
}

type Tardis interface {

	// Visit visit any object that implements the Companion interface
	Visit(ctx context.Context, object any)

	// GetDoctor will call the doctor, are you ready for him is the question.
	GetDoctor() Doctor
}

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

type Walkable interface {
	Walk(context.Context, *base.SchemaProxy)
}

type WalkedHeader struct {
	Header     any
	HeaderNode *yaml.Node
}

type WalkedMediaType struct {
	MediaType     any
	MediaTypeNode *yaml.Node
}

type WalkedParam struct {
	Param     any
	ParamNode *yaml.Node
}

type WalkedSchema struct {
	Schema     *Schema
	SchemaNode *yaml.Node
}

type XML struct {
	Value *base.XML
	Foundation
}