internal

type ApplyPatchOptions struct {
	Mutate           bool
	JsonPatchOptions JsonPatchOptions
}

type Codec interface {
	// Decode decodes a JSON operation object into an Op instance
	Decode(operation Operation) (Op, error)
	// DecodeSlice decodes an array of operations into an Op slice
	DecodeSlice(operations []Operation) ([]Op, error)
	// Encode encodes an Op instance into a JSON operation object
	Encode(op Op) (Operation, error)
	// EncodeSlice encodes an Op slice into an array of operations
	EncodeSlice(ops []Op) ([]Operation, error)
}

type CompactOperation = []interface{}

type CreateRegexMatcher func(pattern string, ignoreCase bool) RegexMatcher

type JsonPatchOptions struct {
	CreateMatcher CreateRegexMatcher
}

type JsonPatchTypes string

type Op interface {
	// Op returns the operation type string (e.g. "add", "remove", etc.)
	Op() OpType
	// Code returns the numeric code for the operation (consistent with constants)
	Code() int
	// Path returns the JSON Pointer path for the operation (slice form)
	Path() []string
	// Apply applies the operation to the document, returning the new document and old value
	Apply(doc any) (OpResult, error)
	// ToJSON returns the standard JSON Patch format
	ToJSON() (Operation, error)
	// ToCompact returns the compact array format
	ToCompact() (CompactOperation, error)
	// Validate validates the operation parameters
	Validate() error
}

type OpResult struct {
	Doc interface{} `json:"doc"`
	Old interface{} `json:"old,omitempty"`
}

type OpType string

type Operation = map[string]interface{}

type PatchResult struct {
	Doc interface{} `json:"doc"`
	Res []OpResult  `json:"res"`
}

type PredicateOp interface {
	Op
	// Test tests the operation on the document, returning whether it passed
	Test(doc any) (bool, error)
	// Not returns whether the operation is a negation predicate
	Not() bool
}

type RegexMatcher func(value string) bool

type SecondOrderPredicateOp interface {
	PredicateOp
	// Ops returns all sub-predicate operations
	Ops() []PredicateOp
}