model

type Agent struct {
	Metadata AgentMetadata
	Spec     AgentSpec
	Status   AgentStatus
}

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

type AgentCertificate struct {
	Cert       []byte
	PrivateKey []byte
	CaCert     []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 AgentCondition struct {
	// Type is the type of the condition.
	Type AgentConditionType
	// LastTransitionTime is the last time the condition transitioned.
	LastTransitionTime time.Time
	// Status is the status of the condition.
	Status AgentConditionStatus
	// Reason is the identifier of the user or system that triggered the condition.
	Reason string
	// Message is a human readable message indicating details about the condition.
	Message string
}

type AgentConditionStatus string

type AgentConditionType string

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 AgentConnectionSettingsStatus struct {
	LastConnectionSettingsHash []byte
	Status                     ConnectionSettingsStatus
	ErrorMessage               string
}

type AgentCustomCapabilities struct {
	Capabilities []string
}

type AgentEffectiveConfig struct {
	ConfigMap AgentConfigMap
}

type AgentGroup struct {
	Metadata AgentGroupMetadata
	Spec     AgentGroupSpec
	Status   AgentGroupStatus
}

type AgentGroupAgentRemoteConfig struct {
	// AgentRemoteConfigName is the name of a standalone remote configuration resource.
	AgentRemoteConfigName *string
	// AgentRemoteConfigSpec is the remote configuration to be applied to agents in this group.
	AgentRemoteConfigSpec *AgentRemoteConfigSpec

	// AgentRemoteConfigRef is a reference to a standalone remote configuration resource.
	AgentRemoteConfigRef *string
}

type AgentGroupConnectionConfig struct {
	OpAMPConnection  *OpAMPConnectionSettings
	OwnMetrics       *TelemetryConnectionSettings
	OwnLogs          *TelemetryConnectionSettings
	OwnTraces        *TelemetryConnectionSettings
	OtherConnections map[string]OtherConnectionSettings
}

type AgentGroupMetadata struct {
	// Name is the name of the agent group.
	Name string
	// Attributes is a map of attributes associated with the agent group.
	Attributes Attributes
	// CreatedAt is the timestamp when the agent group was created.
	CreatedAt time.Time
	// DeletedAt is the timestamp when the agent group was soft deleted.
	// If is zero, the agent group is not deleted.
	DeletedAt time.Time
}

type AgentGroupSpec struct {
	// Priority is the priority of the agent group.
	// When multiple agent groups match an agent, the one with the highest priority is applied.
	Priority int

	// Selector is a set of criteria used to select agents for the group.
	Selector AgentSelector

	// AgentRemoteConfig is a single remote configuration (for API compatibility).
	// Deprecated: Use AgentRemoteConfigs for multiple configs.
	AgentRemoteConfig *AgentGroupAgentRemoteConfig

	// AgentRemoteConfigs is a list of remote configurations for the agent group.
	AgentRemoteConfigs []AgentGroupAgentRemoteConfig

	// AgentConnection settings for agents in this group.
	AgentConnectionConfig *AgentGroupConnectionConfig
}

type AgentGroupStatus struct {
	// NumAgents is the total number of agents in the agent group.
	// NumAgents = NumConnectedAgents + NumNotConnectedAgents
	NumAgents int

	// NumConnectedAgents is the number of connected agents in the agent group.
	// NumConnectedAgents = NumHealthyAgents + NumUnhealthyAgents
	NumConnectedAgents int

	// NumHealthyAgents is the number of healthy agents in the agent group.
	NumHealthyAgents int

	// NumUnhealthyAgents is the number of unhealthy agents in the agent group.
	NumUnhealthyAgents int

	// NumNotConnectedAgents is the number of not connected agents in the agent group.
	NumNotConnectedAgents int

	// Conditions is a list of conditions that apply to the agent group.
	Conditions []Condition
}

type AgentMetadata struct {
	// InstanceUID is a unique identifier for the agent instance.
	// It is generated by the agent and should not change between restarts of the agent.
	InstanceUID uuid.UUID

	// Description is a agent description defined in the opamp protocol.
	// It is set by the agent and should not change between restarts of the agent.
	// It can be changed by the agent at any time.
	Description agent.Description

	// Capabilities is a agent capabilities defined in the opamp protocol.
	Capabilities agent.Capabilities

	// CustomCapabilities is a list of custom capabilities that the Agent supports.
	CustomCapabilities AgentCustomCapabilities
}

type AgentOpAMPConnectionSettings struct {
	DestinationEndpoint string
	Headers             map[string][]string
	Certificate         *AgentCertificate
}

type AgentOption func(*Agent)

type AgentOtherConnectionSettings struct {
	DestinationEndpoint string
	Headers             map[string][]string
	Certificate         *AgentCertificate
}

type AgentPackage struct {
	Metadata AgentPackageMetadata
	Spec     AgentPackageSpec
	Status   AgentPackageStatus
}

type AgentPackageMetadata struct {
	Name       string
	Attributes Attributes
	// CreatedAt is the timestamp when the agent package was created.
	CreatedAt time.Time
	// DeletedAt is the timestamp when the agent package was soft deleted.
	// If nil, the agent package is not deleted.
	DeletedAt *time.Time
}

type AgentPackageSpec struct {
	PackageType string
	Version     string
	DownloadURL string
	ContentHash []byte
	Signature   []byte
	Headers     map[string]string
	Hash        []byte
}

type AgentPackageStatus struct {
	Conditions []Condition
}

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

type AgentPackageStatusEnum int32

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

type AgentRemoteConfig struct {
	Metadata AgentRemoteConfigMetadata
	Spec     AgentRemoteConfigSpec
	Status   AgentRemoteConfigResourceStatus
}

type AgentRemoteConfigMetadata struct {
	Name       string
	Attributes Attributes
	CreatedAt  time.Time
	DeletedAt  *time.Time
}

type AgentRemoteConfigResourceStatus struct {
	Conditions []Condition
}

type AgentRemoteConfigSpec struct {
	// Value is the configuration content.
	Value []byte
	// ContentType is the MIME type of the configuration content.
	ContentType string
}

type AgentRemoteConfigStatus struct {
	LastRemoteConfigHash []byte
	Status               RemoteConfigStatus
	ErrorMessage         string
	LastUpdatedAt        time.Time
}

type AgentRestartInfo struct {
	// RequiredRestartedAt is the time when the agent is required to be
	// restarted to apply a command that requires a restart.
	RequiredRestartedAt time.Time
}

type AgentSelector struct {
	// IdentifyingAttributes is a map of identifying attributes used to select agents.
	IdentifyingAttributes map[string]string
	// NonIdentifyingAttributes is a map of non-identifying attributes used to select agents.
	NonIdentifyingAttributes map[string]string
}

type AgentSpec struct {
	// NewInstanceUID is a new instance UID to inform the agent of its new identity.
	NewInstanceUID uuid.UUID

	// RestartInfo contains information about agent restart.
	RestartInfo *AgentRestartInfo

	// ConnectionInfo is the connection information for the agent.
	ConnectionInfo *ConnectionInfo

	// RemoteConfig is the remote configuration for the agent.
	RemoteConfig *AgentSpecRemoteConfig

	// PackagesAvailable is the packages available for the agent.
	PackagesAvailable *AgentSpecPackage
}

type AgentSpecPackage struct {
	// Packages is a list of package names available for the agent.
	Packages []string
}

type AgentSpecRemoteConfig struct {
	ConfigMap AgentConfigMap
}

type AgentStatus struct {
	RemoteConfigStatus       AgentRemoteConfigStatus
	ConnectionSettingsStatus AgentConnectionSettingsStatus
	EffectiveConfig          AgentEffectiveConfig
	PackageStatuses          AgentPackageStatuses
	ComponentHealth          AgentComponentHealth
	AvailableComponents      AgentAvailableComponents

	// Conditions is a list of conditions that apply to the agent.
	// WARNING: Do NOT use Conditions for MongoDB queries or aggregations.
	// The Conditions field can be null which causes MongoDB aggregation errors
	// (e.g., $anyElementTrue's argument must be an array, but is null).
	// Use the following indexed fields instead:
	// - Connected (bool): for connection status queries
	// - ComponentHealth.Healthy (bool): for health status queries
	Conditions []AgentCondition

	Connected      bool
	ConnectionType ConnectionType

	SequenceNum    uint64
	LastReportedAt time.Time
	// LastReportedTo is the ID of the server the agent last reported to.
	// When you want to get Server object, use `GetServerByID` function from ServerUsecase.
	LastReportedTo string
}

type AgentTelemetryConnectionSettings struct {
	DestinationEndpoint string
	Headers             map[string][]string
	Certificate         *AgentCertificate
}

type Attributes map[string]string

type Certificate struct {
	Metadata CertificateMetadata
	Spec     CertificateSpec
	Status   CertificateStatus
}

type CertificateMetadata struct {
	Name       string
	Attributes Attributes
	// CreatedAt is the timestamp when the certificate was created.
	CreatedAt time.Time
	// DeletedAt is the timestamp when the certificate was soft deleted.
	// If zero, the certificate is not deleted.
	DeletedAt time.Time
}

type CertificateSpec struct {
	Cert       []byte
	PrivateKey []byte
	CaCert     []byte
}

type CertificateStatus struct {
	Conditions []Condition
}

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

type Condition struct {
	// Type is the type of the condition.
	Type ConditionType
	// LastTransitionTime is the last time the condition transitioned.
	LastTransitionTime time.Time
	// Status is the status of the condition.
	Status ConditionStatus
	// Reason is the identifier of the user or system that triggered the condition.
	Reason string
	// Message is a human readable message indicating details about the condition.
	Message string
}

type ConditionStatus string

type ConditionType string

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 ConnectionType

	// 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 ConnectionInfo struct {
	Hash vo.Hash
	// contains filtered or unexported fields
}

type ConnectionOption interface {
	// contains filtered or unexported methods
}

type ConnectionOptionFunc func(*connectionSettings)

type ConnectionSettingsStatus int32

type ConnectionType int

type Host struct{}

type ListOptions struct {
	Limit    int64
	Continue string
}

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

type OpAMPConnectionSettings struct {
	DestinationEndpoint string
	Headers             map[string][]string
	CertificateName     *string
}

type OtherConnectionSettings struct {
	DestinationEndpoint string
	Headers             map[string][]string
	CertificateName     *string
}

type RemoteConfigStatus int32

type Server struct {
	// ID is the unique identifier for the server.
	ID string
	// LastHeartbeatAt is the last time the server sent a heartbeat.
	LastHeartbeatAt time.Time
	// Conditions is a list of conditions that apply to the server.
	Conditions []Condition
}

type TelemetryConnectionSettings struct {
	DestinationEndpoint string
	Headers             map[string][]string
	CertificateName     *string
}