dtclient

type Client interface {
	ConfigClient
	SettingsClient
}

type ConfigClient interface {
	// ListConfigs lists the available configs for an API.
	// It calls the underlying GET endpoint of the API. E.g. for alerting profiles this would be:
	//    GET <environment-url>/api/config/v1/alertingProfiles
	// The result is expressed using a list of Value (id and name tuples).
	ListConfigs(ctx context.Context, a api.API) (values []Value, err error)

	// ReadConfigById reads a Dynatrace config identified by id from the given API.
	// It calls the underlying GET endpoint for the API. E.g. for alerting profiles this would be:
	//    GET <environment-url>/api/config/v1/alertingProfiles/<id> ... to get the alerting profile
	ReadConfigById(a api.API, id string) (json []byte, err error)

	// UpsertConfigByName creates a given Dynatrace config if it doesn't exist and updates it otherwise using its name.
	// It calls the underlying GET, POST, and PUT endpoints for the API. E.g. for alerting profiles this would be:
	//    GET <environment-url>/api/config/v1/alertingProfiles ... to check if the config is already available
	//    POST <environment-url>/api/config/v1/alertingProfiles ... afterwards, if the config is not yet available
	//    PUT <environment-url>/api/config/v1/alertingProfiles/<id> ... instead of POST, if the config is already available
	UpsertConfigByName(ctx context.Context, a api.API, name string, payload []byte) (entity DynatraceEntity, err error)

	// UpsertConfigByNonUniqueNameAndId creates a given Dynatrace config if it doesn't exist and updates it based on specific rules if it does not
	// - if only one config with the name exist, behave like any other type and just update this entity
	// - if an exact match is found (same name and same generated UUID) update that entity
	// - if several configs exist, but non match the generated UUID create a new entity with generated UUID
	// It calls the underlying GET and PUT endpoints for the API. E.g. for alerting profiles this would be:
	//	 GET <environment-url>/api/config/v1/alertingProfiles ... to check if the config is already available
	//	 PUT <environment-url>/api/config/v1/alertingProfiles/<id> ... with the given (or found by unique name) entity ID
	UpsertConfigByNonUniqueNameAndId(ctx context.Context, a api.API, entityID string, name string, payload []byte, duplicate bool) (entity DynatraceEntity, err error)

	// DeleteConfigById removes a given config for a given API using its id.
	// It calls the DELETE endpoint for the API. E.g. for alerting profiles this would be:
	//    DELETE <environment-url>/api/config/v1/alertingProfiles/<id> ... to delete the config
	DeleteConfigById(a api.API, id string) error

	// ConfigExistsByName checks if a config with the given name exists for the given API.
	// It calls the underlying GET endpoint for the API. E.g. for alerting profiles this would be:
	//    GET <environment-url>/api/config/v1/alertingProfiles
	ConfigExistsByName(ctx context.Context, a api.API, name string) (exists bool, id string, err error)
}

type DataEntry struct {
	Name    string
	Id      string
	Owner   string
	Payload []byte
}

type DownloadSettingsObject struct {
	ExternalId       string                    `json:"externalId"`
	SchemaVersion    string                    `json:"schemaVersion"`
	SchemaId         string                    `json:"schemaId"`
	ObjectId         string                    `json:"objectId"`
	Scope            string                    `json:"scope"`
	Value            json.RawMessage           `json:"value"`
	ModificationInfo *SettingsModificationInfo `json:"modificationInfo"`
}

type DummyClient struct {
	Fs               afero.Fs
	RequestOutputDir string
	// contains filtered or unexported fields
}

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

type DynatraceEntity struct {
	Id          string `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description"`
}

type KeyUserActionsMobileResponse struct {
	KeyUserActions []struct {
		Name string `json:"name"`
	} `json:"keyUserActions"`
}

type ListSettingsFilter func(DownloadSettingsObject) bool

type ListSettingsOptions struct {
	// DiscardValue specifies whether the value field of the returned
	// settings object shall be included in the payload
	DiscardValue bool
	// ListSettingsFilter can be set to pre-filter the result given a special logic
	Filter ListSettingsFilter
}

type Properties struct {
	Version *string `json:"version"`
}

type SchemaConstraints struct {
	SchemaId         string
	UniqueProperties [][]string
}

type SchemaList []struct {
	SchemaId string `json:"schemaId"`
}

type SchemaListResponse struct {
	Items      SchemaList `json:"items"`
	TotalCount int        `json:"totalCount"`
}

type SettingsClient interface {
	// UpsertSettings either creates the supplied object, or updates an existing one.
	// First, we try to find the external-id of the object. If we can't find it, we create the object, if we find it, we
	// update the object.
	UpsertSettings(context.Context, SettingsObject, UpsertSettingsOptions) (DynatraceEntity, error)

	// ListSchemas returns all schemas that the Dynatrace environment reports
	ListSchemas() (SchemaList, error)

	FetchSchemasConstraints(schemaID string) (SchemaConstraints, error)

	// ListSettings returns all settings objects for a given schema.
	ListSettings(context.Context, string, ListSettingsOptions) ([]DownloadSettingsObject, error)

	// GetSettingById returns the setting with the given object ID
	GetSettingById(string) (*DownloadSettingsObject, error)

	// DeleteSettings deletes a settings object giving its object ID
	DeleteSettings(string) error
}

type SettingsModificationInfo struct {
	Deletable          bool          `json:"deletable"`
	Modifiable         bool          `json:"modifiable"`
	Movable            bool          `json:"movable"`
	ModifiablePaths    []interface{} `json:"modifiablePaths"`
	NonModifiablePaths []interface{} `json:"nonModifiablePaths"`
}

type SettingsObject struct {
	// Coordinate holds all the information for Monaco to identify a settings object
	Coordinate coordinate.Coordinate
	// SchemaId is the Dynatrace settings schema ID
	SchemaId,

	SchemaVersion,

	Scope string
	// Content is the rendered config for the given settings object
	Content []byte
	// OriginObjectId is the object id of the Settings object when it was downloaded from an environment
	OriginObjectId string
}

type SyntheticEntity struct {
	EntityId string `json:"entityId"`
}

type SyntheticLocationResponse struct {
	Locations []SyntheticValue `json:"locations"`
}

type SyntheticMonitorsResponse struct {
	Monitors []SyntheticValue `json:"monitors"`
}

type SyntheticValue struct {
	Name          string    `json:"name"`
	EntityId      string    `json:"entityId"`
	Type          string    `json:"type"`
	CloudPlatform *string   `json:"cloudPlatform"`
	Ips           *[]string `json:"ips"`
	Stage         *string   `json:"stage"`
	Enabled       *bool     `json:"enabled"`
}

type UpsertSettingsOptions struct {
	OverrideRetry *rest.RetrySetting
}

type UserActionAndSessionPropertyEntry struct {
	Key         string `json:"key"`
	DisplayName string `json:"displayName"`
}

type UserActionAndSessionPropertyResponse struct {
	SessionProperties    []UserActionAndSessionPropertyEntry `json:"sessionProperties"`
	UserActionProperties []UserActionAndSessionPropertyEntry `json:"userActionProperties"`
}

type Value struct {
	Id   string `json:"id"`
	Name string `json:"name"`

	// Owner is used by dashboards to indicate the creator of the dashboard. We use it to filter Dynatrace created dashboards.
	Owner *string `json:"owner,omitempty"`

	// Type is used by synthetic-locations to indicate whether it is a PRIVATE location or not.
	Type *string `json:"type,omitempty"`

	// CustomFields holds additional fields. Note that this is not set automatically but would need to be populated
	// when unmarshalling the payload
	CustomFields map[string]any `json:"-"`
}

type ValuesResponse struct {
	Values []Value `json:"values"`
}