assets

type CompareTest func(criterion, available1, available2 any) int

type CompatibilityProfile struct {
	Name            string
	RestoreContexts []*FrameworkRuntimePair // Framework + optional RID pairs
}

type CompatibilityTest func(criterion, available any) bool

type ContentItem struct {
	Path       string
	Properties map[string]any
}

type ContentItemCollection struct {
	Assets []*ContentItem
}

type ContentItemGroup struct {
	Properties map[string]any
	Items      []*ContentItem
}

type FrameworkRuntimePair struct {
	Framework string // e.g., "net46", "netstandard2.0"
	RID       string // Empty string means RID-agnostic, otherwise specific RID
}

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

type ManagedCodeConventions struct {
	// Properties available for pattern matching
	Properties map[string]*PropertyDefinition

	// Pattern sets for different asset types
	RuntimeAssemblies     *PatternSet
	CompileRefAssemblies  *PatternSet
	CompileLibAssemblies  *PatternSet
	NativeLibraries       *PatternSet
	ResourceAssemblies    *PatternSet
	MSBuildFiles          *PatternSet
	MSBuildMultiTargeting *PatternSet
	ContentFiles          *PatternSet
	ToolsAssemblies       *PatternSet
}

type PatternDefinition struct {
	// Pattern is the path template with property placeholders.
	// Example: "lib/{tfm}/{assembly}"
	// Optional properties end with '?': "lib/{any?}"
	Pattern string

	// Defaults provides default property values.
	// Example: {"tfm": &frameworks.NuGetFramework{...}}
	Defaults map[string]any

	// Table is the token replacement table.
	// Maps property values to replacements (e.g., "any" -> DotNet framework)
	Table *PatternTable

	// PreserveRawValues indicates whether to preserve unparsed string values.
	// Performance optimization for grouping operations.
	PreserveRawValues bool
}

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

type PatternSet struct {
	// GroupPatterns match directory-level patterns.
	// Used for grouping items by common properties.
	GroupPatterns []*PatternDefinition

	// PathPatterns match individual file paths.
	// Used for selecting specific assets.
	PathPatterns []*PatternDefinition

	// GroupExpressions are compiled group patterns (for performance).
	GroupExpressions []*PatternExpression

	// PathExpressions are compiled path patterns (for performance).
	PathExpressions []*PatternExpression

	// PropertyDefinitions available for this pattern set.
	PropertyDefinitions map[string]*PropertyDefinition
}

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

type PatternTableEntry struct {
	PropertyName string // Property this entry applies to (e.g., "tfm")
	Name         string // Token name to replace (e.g., "any")
	Value        any    // Replacement value
}

type PropertyDefinition struct {
	// Name is the property identifier (e.g., "tfm", "rid", "assembly")
	Name string

	// FileExtensions for file-based properties (e.g., [".dll", ".exe"])
	FileExtensions []string

	// AllowSubFolders allows file extensions to match in subdirectories
	AllowSubFolders bool

	// Parser converts string value to typed value
	Parser PropertyParser

	// CompatibilityTest checks if criterion is satisfied by available value
	CompatibilityTest CompatibilityTest

	// CompareTest finds the nearest candidate
	CompareTest CompareTest
}

type PropertyParser func(value string, table *PatternTable, matchOnly bool) any

type RuntimeDependencySet struct {
	ID           string                               // Package ID that has RID-specific dependencies
	Dependencies map[string]*RuntimePackageDependency // Dependency ID -> version constraint
}

type RuntimeDescription struct {
	RID                 string
	Imports             []string                         // Compatible RIDs (less specific) - JSON key is "#import"
	RuntimeDependencies map[string]*RuntimeDependencySet // Package ID -> RID-specific dependencies
}

type RuntimeGraph struct {
	// Runtimes maps RID to its description
	Runtimes map[string]*RuntimeDescription

	// Supports maps profile name to compatibility profiles
	// Used for portable app compatibility (e.g., "net46.app" profile)
	Supports map[string]*CompatibilityProfile
	// contains filtered or unexported fields
}

type RuntimeIdentifier struct {
	// RID is the raw RID string
	RID string

	// OS is the operating system component (e.g., "win", "linux", "osx")
	OS string

	// Version is the OS version component (e.g., "10.12" in "osx.10.12-x64")
	Version string

	// Architecture is the architecture component (e.g., "x64", "arm64")
	Architecture string

	// Qualifiers are additional qualifiers beyond architecture
	Qualifiers []string
}

type RuntimePackageDependency struct {
	ID           string
	VersionRange string // e.g., "1.0.0", "[1.0.0,2.0.0)"
}

type Segment interface {
	// TryMatch attempts to match this segment against path.
	// Returns true and end index if match succeeds.
	TryMatch(item **ContentItem, path string, properties map[string]*PropertyDefinition, startIndex int) (int, bool)
}

type SelectionCriteria struct {
	Entries []SelectionCriteriaEntry
}

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

type SelectionCriteriaEntry struct {
	Properties map[string]any
}

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