config

type Change struct {
	// Metadata holds metadata associated with a change.
	Metadata ChangeMetadata
	// SemverRange is the version range for which this change must be executed to
	// guarantee compatibility.
	SemverRange string
	// Update holds a declarative definition of the change that must be
	// applied to a specific schema.
	Update ConfigTableUpdates
}

type ChangeDetail struct {
	ID        ChangeID
	Resources []ResourceInfo
}

type ChangeID string

type ChangeMetadata struct {
	// ID identifies a change uniquely. Required.
	ID ChangeID
	// Severity identifies the severity of a change. Required.
	// Read Severities defined in this package for more details.
	Severity ChangeSeverity
	// Description is a human-readable sentence describing the impact of the
	// change. Required.
	Description string
	// Resolution is a human-readable sentence describing the path to
	// resolution. Required.
	Resolution string
	// DocumentationURL is an optional web URL that further details the
	// change or its resolution.
	DocumentationURL string
}

type ChangeSeverity string

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

type CompatChangeRegistry interface {
	// Register registers a change.
	// If a change is already registers or if a change is invalid,
	// it returns an error.
	Register(c Change) error
	// GetMetadata returns ChangeMetadata for an id.
	// It returns ErrRegistryEntryNotFound if a change with id has not been previously
	// registered.
	GetMetadata(id ChangeID) (ChangeMetadata, error)
	// GetUpdates returns configuration updates for all registered
	// changes. The order of updates within a version is not deterministic.
	GetUpdates() VersionedConfigUpdates
}

type ConfigTableFieldCondition struct {
	// Field is a top-level or nested field; use dot notation for nested fields.
	Field string
	// Condition is an expression for matching criteria.
	// uses gjson path syntax; https://github.com/tidwall/gjson#path-syntax
	Condition string
	// Updates is an array of updates to perform based on the matched criteria.
	Updates []ConfigTableFieldUpdate
}

type ConfigTableFieldUpdate struct {
	// Field to perform update or delete operation on; if Value is nil or
	// ValueFromField is empty the field will be removed.
	Field string
	// Value when specified is the value applied to the key referenced in the
	// member Field.
	Value interface{}
	// ValueFromField when specified represents the name of the key whose value is
	// retrieved and applied to the key referenced in the member Field.
	ValueFromField string
}

type ConfigTableUpdates struct {
	// Name is the name of the configuration or field depending on UpdateType.
	Name string
	// UpdateType is the type of update being performed; currently plugins only.
	Type UpdateType
	// RemoveFields will remove fields from the configuration table.
	//
	// Values contained within this array are associated with a field name inside
	// the configuration table. The value can be a top-level field or a nested
	// field which is separated using the dot notation.
	RemoveFields []string
	// RemoveElementsFromArray will remove an array element from a field in the
	// configuration table.
	//
	// Values contained within this array are associated with a field and a
	// condition. If the condition matches for the given field, the array in which
	// the match occurred (e.g. index) will be removed from  the configuration
	// table.
	RemoveElementsFromArray []ConfigTableFieldCondition
	// FieldUpdates will create/update a field to a new value in the configuration
	// table.
	//
	// Values contained within this array are associated with a field, a
	// condition, and an array of updates to perform. New fields can be created,
	// original fields can be updated, and specific fields can be removed
	// depending on the version compatibility requirement of the data plane
	// version being targeted.
	FieldUpdates []ConfigTableFieldCondition
	// Remove indicates whether the whole entity should be removed or not.
	Remove bool

	// ChangeID is a unique identifier for every schema update.
	ChangeID ChangeID

	// DisableChangeTracking takes in JSON encoded string representation of
	// UpdateType denoted by Type defined above.
	// This callback gives an opportunity to the change to dynamically disable
	// change tracking.
	//
	// An example use-case is when a newly added field with a backwards-compatible
	// default value is dropped from the configuration. In this case, the user
	// doesn't need to be notified of a benign change.
	// When unspecified, the change is always emitted.
	DisableChangeTracking func(rawJSON string) bool
}

type Content struct {
	CompressedPayload []byte
	Hash              string
	GranularHashes    map[string]string
}

type DataPlaneConfig Map

type KongCACertificateLoader struct {
	Client admin.CACertificateServiceClient
}

type KongCertificateLoader struct {
	Client admin.CertificateServiceClient
}

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

type KongConsumerLoader struct {
	Client admin.ConsumerServiceClient
}

type KongPluginLoader struct {
	Client admin.PluginServiceClient
}

type KongRouteLoader struct {
	Client admin.RouteServiceClient
}

type KongSNILoader struct {
	Client admin.SNIServiceClient
}

type KongServiceLoader struct {
	Client admin.ServiceServiceClient
}

type KongTargetLoader struct {
	Client admin.TargetServiceClient
}

type KongUpstreamLoader struct {
	Client admin.UpstreamServiceClient
}

type Loader interface {
	Load(ctx context.Context, clusterID string) (Content, error)
}

type Map map[string]interface{}

type Mutator interface {
	Name() string
	Mutate(context.Context, MutatorOpts, DataPlaneConfig) error
}

type MutatorOpts struct {
	ClusterID string
}

type ParametersLoader struct {
	ClusterID string
}

type Processor func(uncompressedPayload string, dataPlaneVersion versioning.Version,
	tracker *ChangeTracker, logger *zap.Logger) (string, error)

type ResourceInfo struct {
	Type string
	ID   string
}

type TrackedChanges struct {
	// Changes are resource-specific changes.
	ChangeDetails []ChangeDetail
}

type UpdateType uint8

type VersionCompatibility interface {
	AddConfigTableUpdates(configTableUpdates VersionedConfigUpdates) error
	ProcessConfigTableUpdates(dataPlaneVersionStr string, compressedPayload []byte) ([]byte, TrackedChanges, error)
}

type VersionCompatibilityOpts struct {
	Logger         *zap.Logger
	KongCPVersion  string
	ExtraProcessor Processor
}

type VersionLoader struct{}

type VersionedConfigUpdates map[string][]ConfigTableUpdates

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