runtime

type ChangeListener interface {
	// NotifyChange is called when an instance of a specific configuration section
	// is created, modified or deleted. The changeType parameter will be set to
	// "create", "update" or "delete" respectively with id holding a unique identifier
	// for the section. Note that sec is only set for create or update operations but MAY
	// be omitted during deletes.
	// Note that any error returned from this callback is displayed to the user but does
	// NOT prevent that change from happening!
	NotifyChange(ctx context.Context, changeType, id string, sec *conf.Section) error
}

type ConfigProvider interface {
	// Create should store a new configuration section and return a unique
	// ID for that section.
	Create(ctx context.Context, sec conf.Section) (id string, err error)

	// Update should update an existing configuration section by id. opts
	// holds the new configuration data for that section.
	Update(ctx context.Context, id string, secType string, opts []conf.Option) error

	// Delete should delete an existing configuration section by id.
	Delete(ctx context.Context, id string) error

	// Get returns all options for the given sectionType.
	Get(ctx context.Context, sectionType string) ([]Section, error)

	// GetID returns the section by ID.
	GetID(ctx context.Context, id string) (Section, error)
}

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

type ConfigSchemaBuilder []func(*ConfigSchema) error

type ConfigTest struct {
	// ID is a unique ID for this configuration test and used to identify
	// and trigger the test.
	ID string `json:"id"`

	// Name holds a human readable name of the test and is used when the user
	// can select between available config tests.
	Name string `json:"name"`

	// Spec defines a set of options that the user can or must provide in order to
	// test a configuration schema.
	Spec conf.OptionRegistry `json:"spec"`

	// TestFunc is called to verify that config works as expected. config adheres to the
	// schema specification. testSpec is the configuration to execute the test and may hold
	// additional data like the receiver of a test notification.
	TestFunc func(ctx context.Context, config []conf.Option, testSpec []conf.Option) (*TestResult, error) `json:"-"`
}

type NotificationError struct {
	Wrapped error
}

type OneOfAnnotation struct {
	Values []PossibleValue `json:"values,omitempty"`
	// AllowCustomValue can be set to true if custom values
	// should also be allowed for the annoated option.
	AllowCustomValue bool `json:"allowCustomValue"`
}

type OneOfReference struct {
	// SchemaType is the name of the schema that
	// holds possible values.
	SchemaType string `json:"schemaType"`
	// ValueField is the name of the field in the referenced
	// schema.
	ValueField string `json:"valueField"`
	// DisplayFiled is the name fo the field that should be diplayed
	// in the user interface.
	DisplayField string `json:"displayField,omitempty"`
	// AllowCustomValue can be set to true if custom values
	// should also be allowed for the annoated option.
	AllowCustomValue bool `json:"allowCustomValue"`
}

type PossibleValue struct {
	Display string      `json:"display"`
	Value   interface{} `json:"value"`
}

type Schema struct {
	// Name is the name of the registration block and is used to identify the allowed
	// values of a configuration.
	// Name is required when registering a new configuration block.
	Name string `json:"name"`

	// DisplayName holds a human readable name for the schema type and is mainly used
	// in the user interface. If omitted, DisplayName is set to equal Name.
	DisplayName string `json:"displayName"`

	// SVGData may hold an icon definition that may be rendered in a <svg> tag
	// in a user interface.
	SVGData string `json:"svgData,omitempty"`

	// Description holds a human readable description of the configuration block and
	// is mainly used by the user interface.
	// Description is optional.
	Description string `json:"description"`

	// Category defines the category the configuration section belongs to.
	// Categories can be used to group related sections together in the user
	// interface.
	Category string `json:"category"`

	// Spec holds the actual section registry that defines which sections, values and
	// which types are allowed for instances of the configuration block.
	// Spec is required when registering a new configuration block.
	Spec conf.OptionRegistry `json:"-"`

	// Multi should be set to true if multiple instances of the registered
	// configuration can exist at the same time.
	Multi bool `json:"multi"`

	// Internal can be set to true if the schema should not be exposed via
	// the REST API.
	Internal bool `json:"internal"`

	// Annotations may hold additional annotations about the configuration schema. Those
	// annotations may be, for example, used by user interfaces to determine how to
	// best display the configuration setting.
	Annotations conf.Annotation `json:"annotation"`

	// Tests may hold one or more configuration test that a user may perform in order to
	// be certain that a configuration schema works as expected.
	Tests []ConfigTest `json:"tests,omitempty"`
}

type Section struct {
	ID string
	conf.Section
}

type StringFormatAnnotation struct {
	// Format defines the format of the annotated string
	// value.
	//
	// Valid values are:
	//
	//	- text/plain
	//	- text/markdown
	//	- application/json
	//
	Format string `json:"format"`
}

type TestResult struct {
	Error   string `json:"error"`
	Message string `json:"message,omitempty"`
}

type Validator interface {
	// Validate can be set if if the configuration section must be externally validated
	// before being created or updated.
	// The parameter id is only set in case of an update. Users should be aware that
	// even if ValidateFunc returns a nil-error the section might fail to be saved successfully.
	// Users should use a ChangeListener callback instead.
	Validate(ctx context.Context, sec Section) error
}