model

type Agent struct {
	InstanceUID uuid.UUID

	// Agent To Server message
	Capabilities        *agent.Capabilities
	Description         *agent.Description
	EffectiveConfig     *AgentEffectiveConfig
	PackageStatuses     *AgentPackageStatuses
	ComponentHealth     *AgentComponentHealth
	RemoteConfig        remoteconfig.RemoteConfig
	CustomCapabilities  *AgentCustomCapabilities
	AvailableComponents *AgentAvailableComponents

	// ReportFullState is a flag to indicate whether the agent should report full state.
	// If true, the agent should report all state information.
	// More details, see https://github.com/open-telemetry/opamp-spec/blob/main/specification.md#servertoagentflags
	ReportFullState bool
}

type AgentAvailableComponents struct {
	Components map[string]ComponentDetails
	Hash       []byte
}

type AgentComponentHealth struct {
	// Set to true if the Agent is up and healthy.
	Healthy bool

	// Timestamp since the Agent is up
	StartTime time.Time

	// Human-readable error message if the Agent is in erroneous state. SHOULD be set when healthy==false.
	LastError string

	// Component status represented as a string.
	// The status values are defined by agent-specific semantics and not at the protocol level.
	Status string

	// The time when the component status was observed.
	StatusTime time.Time

	// A map to store more granular, sub-component health.
	// It can nest as deeply as needed to describe the underlying system.
	ComponentHealthMap map[string]AgentComponentHealth
}

type AgentConfigFile struct {
	// The body field contains the raw bytes of the configuration file.
	// The content, format and encoding of the raw bytes is Agent type-specific and is outside the concerns of OpAMP
	// protocol.
	Body []byte

	// content_type is an optional field. It is a MIME Content-Type that describes what's contained in the body field,
	// for example "text/yaml". The content_type reported in the Effective Configuration in the Agent's status report may
	// be used for example by the Server to visualize the reported configuration nicely in a UI.
	ContentType string
}

type AgentConfigMap struct {
	// The config_map field of the AgentConfigSet message is a map of configuration files, where keys are file names.
	ConfigMap map[string]AgentConfigFile
}

type AgentCustomCapabilities struct {
	Capabilities []string
}

type AgentEffectiveConfig struct {
	ConfigMap AgentConfigMap
}

type AgentPackageStatus struct {
	Name                 string
	AgentHasVersion      string
	AgentHasHash         []byte
	ServerOfferedVersion string
	Status               AgentPackageStatusEnum
	ErrorMessage         string
}

type AgentPackageStatusEnum int32

type AgentPackageStatuses struct {
	Packages                     map[string]AgentPackageStatus
	ServerProvidedAllPackgesHash []byte
	ErrorMessage                 string
}

type AgentRemoteConfigStatus struct {
	LastRemoteConfigHash []byte
	Status               remoteconfig.Status
	ErrorMessage         string
}

type Command struct {
	Kind CommandKind

	ID                uuid.UUID
	TargetInstanceUID uuid.UUID
	Data              map[string]any
}

type CommandKind string

type ComponentDetails struct {
	Metadata        map[string]string
	SubComponentMap map[string]ComponentDetails
}

type Connection struct {
	// Key is the unique identifier for the connection.
	// It should be unique across all connections to use as a key in a map.
	// Normally, it is [types.Connection] by OpAMP.
	ID any

	// Type is the type of the connection.
	Type Type

	// UID is the unique identifier for the connection.
	// It is used to identify the connection in the database.
	UID uuid.UUID

	// InstanceUID is id of the agent.
	InstanceUID uuid.UUID

	// LastCommunicatedAt is the last time the connection was communicated with.
	LastCommunicatedAt time.Time
}

type Host struct{}

type ListOptions struct {
	Limit    int64
	Continue string
}

type ListResponse[T any] struct {
	RemainingItemCount int64
	Continue           string
	Items              []T
}

type Type int