filter

type Boolean struct {
	Eq     *bool
	Neq    *bool
	IsNull *bool
}

type ComplexityLimits struct {
	MaxDepth            int // Maximum nesting depth of relationship filters
	MaxTotalFields      int // Maximum total number of field filters
	MaxLogicalOperators int // Maximum number of logical operators (And/Or/Not)
	MaxLogicalDepth     int // Maximum nesting depth of logical operators
	MaxOrBranches       int // Maximum branches in a single Or operator
}

type ComplexityResult struct {
	Depth            int // Deepest nesting level reached
	TotalFields      int // Total number of field filters
	LogicalOperators int // Total number of logical operators
	LogicalDepth     int // Deepest logical operator nesting
	OrBranches       int // Maximum branches found in any Or operator
}

type Float struct {
	Eq     *float64
	Neq    *float64
	Lt     *float64
	Lte    *float64
	Gt     *float64
	Gte    *float64
	In     []float64
	NotIn  []float64
	IsNull *bool
}

type ID String

type Int struct {
	Eq     *int
	Neq    *int
	Lt     *int
	Lte    *int
	Gt     *int
	Gte    *int
	In     []int
	NotIn  []int
	IsNull *bool
}

type KeyPath []string

type KeyType string

type String struct {
	Eq         *string
	Neq        *string
	Lt         *string
	Lte        *string
	Gt         *string
	Gte        *string
	In         []string
	NotIn      []string
	IsNull     *bool
	Contains   *string
	StartsWith *string
	EndsWith   *string
	Fold       bool
}

type Time struct {
	Eq     *time.Time
	Neq    *time.Time
	Lt     *time.Time
	Lte    *time.Time
	Gt     *time.Time
	Gte    *time.Time
	In     []time.Time
	NotIn  []time.Time
	IsNull *bool
}

type TransformFunc func(input *TransformInput) (*TransformOutput, error)

type TransformInput struct {
	KeyPath    KeyPath
	KeyType    KeyType
	Value      any
	Containers []any // Containers[i] is the container that holds KeyPath[i]
}

type TransformOutput struct {
	Key   string
	Value any
}