version

type AbsoluteParser[A any] struct {
	// Parsers is the list of specifier parsers to try, in order.
	Parsers []SpecifierParser[A]

	// Zero returns the zero/default value of A.
	// Called when no absolute specifier is present in the input.
	Zero func() A
}

type Spec[A any] struct {
	Name     string // Parameter/secret name (e.g., "/my/param", "my-secret")
	Absolute A      // Absolute version specifier (type-specific, zero value if not specified)
	Shift    int    // Relative shift amount (0 means no shift, positive means go back N versions)
}

type SpecifierParser[A any] struct {
	// PrefixChar is the character that starts this specifier (e.g., '#', ':').
	PrefixChar byte

	// IsChar returns true if the byte is valid within this specifier's value.
	// Used to determine where the specifier value ends.
	// Example: for "#123", IsChar would return true for '1', '2', '3'.
	IsChar func(byte) bool

	// Error is returned when PrefixChar is found but not followed by a valid char.
	// If nil, the PrefixChar is treated as part of the name instead of an error.
	// Example: "#" at end of input, or "#" followed by invalid char.
	Error error

	// Duplicated returns true if this specifier type is already set in abs.
	// Used to detect conflicting specifiers (e.g., both #id and :label in Secrets Manager).
	// Can be nil if duplicate checking is not needed.
	Duplicated func(abs A) bool

	// Apply assigns the parsed value to abs and returns the updated abs.
	// The value parameter is the string after PrefixChar (e.g., "123" for "#123").
	// Should only do assignment; validation errors (like overflow) are wrapped by caller.
	Apply func(value string, abs A) (A, error)
}