notify

type APIReceiver struct {
	ConfigReceiver        `yaml:",inline"`
	models.ReceiverConfig `yaml:",inline"`
}

type Alert = types.Alert

type AlertGroup = amv2.AlertGroup

type AlertGroups = amv2.AlertGroups

type AlertValidationError struct {
	Alerts amv2.PostableAlerts
	Errors []error // Errors[i] refers to Alerts[i].
}

type ClusterPeer interface {
	AddState(string, cluster.State, prometheus.Registerer, ...cluster.ChannelOption) cluster.ClusterChannel
	Position() int
	WaitReady(context.Context) error
}

type ConfigFingerprint struct {
	Overall uint64

	RoutingTree       uint64
	InhibitRules      uint64
	MuteTimeIntervals uint64
	TimeIntervals     uint64
	Templates         uint64
	Receivers         uint64
	Limits            uint64
}

type ConfigReceiver = definition.Receiver

type DecodeSecretsFn func(secrets map[string]string) (map[string][]byte, error)

type DispatchTimer int

type DispatcherLimits = dispatch.Limits

type DynamicLimits struct {
	Dispatcher DispatcherLimits
	Templates  templates.Limits
}

type FakeConfig struct {
}

type GetDecryptedValueFn func(ctx context.Context, sjd map[string][]byte, key string, fallback string) string

type GettableAlert = amv2.GettableAlert

type GettableAlerts = amv2.GettableAlerts

type GettableSilence = amv2.GettableSilence

type GettableSilences = amv2.GettableSilences

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

type GrafanaAlertmanagerMetrics struct {
	Registerer prometheus.Registerer
	*metrics.Alerts
	// contains filtered or unexported fields
}

type GrafanaAlertmanagerOpts struct {
	ExternalURL        string
	AlertStoreCallback mem.AlertStoreCallback
	PeerTimeout        time.Duration

	Silences MaintenanceOptions
	Nflog    MaintenanceOptions
	FlushLog MaintenanceOptions

	Limits Limits

	EmailSender   receivers.EmailSender
	ImageProvider images.Provider
	Decrypter     GetDecryptedValueFn

	Version   string
	TenantKey string
	TenantID  int64

	Peer    ClusterPeer
	Logger  log.Logger
	Metrics *GrafanaAlertmanagerMetrics

	NotificationHistorian nfstatus.NotificationHistorian

	DispatchTimer DispatchTimer
}

type GrafanaReceiverConfig struct {
	Name                string
	AlertmanagerConfigs []*NotifierConfig[alertmanager.Config]
	DingdingConfigs     []*NotifierConfig[dingding.Config]
	DiscordConfigs      []*NotifierConfig[discord.Config]
	EmailConfigs        []*NotifierConfig[email.Config]
	GooglechatConfigs   []*NotifierConfig[googlechat.Config]
	JiraConfigs         []*NotifierConfig[jira.Config]
	KafkaConfigs        []*NotifierConfig[kafka.Config]
	LineConfigs         []*NotifierConfig[line.Config]
	OpsgenieConfigs     []*NotifierConfig[opsgenie.Config]
	MqttConfigs         []*NotifierConfig[mqtt.Config]
	PagerdutyConfigs    []*NotifierConfig[pagerduty.Config]
	OnCallConfigs       []*NotifierConfig[oncall.Config]
	PushoverConfigs     []*NotifierConfig[pushover.Config]
	SensugoConfigs      []*NotifierConfig[sensugo.Config]
	SlackConfigs        []*NotifierConfig[slack.Config]
	SNSConfigs          []*NotifierConfig[sns.Config]
	TeamsConfigs        []*NotifierConfig[teams.Config]
	TelegramConfigs     []*NotifierConfig[telegram.Config]
	ThreemaConfigs      []*NotifierConfig[threema.Config]
	VictoropsConfigs    []*NotifierConfig[victorops.Config]
	WebhookConfigs      []*NotifierConfig[webhook.Config]
	WecomConfigs        []*NotifierConfig[wecom.Config]
	WebexConfigs        []*NotifierConfig[webex.Config]
}

type InhibitRule = config.InhibitRule

type Integration = nfstatus.Integration

type IntegrationTimeoutError struct {
	Integration *models.IntegrationConfig
	Err         error
}

type IntegrationValidationError struct {
	Err         error
	Integration *models.IntegrationConfig
}

type Limits struct {
	MaxSilences         int
	MaxSilenceSizeBytes int
}

type MaintenanceOptions interface {
	// InitialState returns the initial snapshot of the artefacts under maintenance. This will be loaded when the Alertmanager starts.
	InitialState() string
	// Retention represents for how long should we keep the artefacts under maintenance.
	Retention() time.Duration
	// MaintenanceFrequency represents how often should we execute the maintenance.
	MaintenanceFrequency() time.Duration
	// MaintenanceFunc returns the function to execute as part of the maintenance process. This will usually take a snaphot of the artefacts under maintenance.
	// It returns the size of the state in bytes or an error if the maintenance fails.
	MaintenanceFunc(state State) (int64, error)
}

type MimirIntegrationConfig struct {
	Schema schema.IntegrationSchemaVersion
	Config any
}

type MuteTimeInterval = config.MuteTimeInterval

type NilChannel struct{}

type NilPeer struct{}

type NotificationsConfiguration struct {
	RoutingTree       *Route
	InhibitRules      []InhibitRule
	MuteTimeIntervals []MuteTimeInterval
	TimeIntervals     []TimeInterval
	Templates         []templates.TemplateDefinition
	Receivers         []*APIReceiver

	Limits DynamicLimits
}

type Notifier = notify.Notifier

type NotifierConfig[T interface{}] struct {
	receivers.Metadata
	Settings         T
	HTTPClientConfig *http.HTTPClientConfig
}

type NotifyReceiver = nfstatus.Receiver

type PostableAlert = amv2.PostableAlert

type PostableAlerts = amv2.PostableAlerts

type PostableSilence = amv2.PostableSilence

type Receiver = amv2.Receiver

type Route = definition.Route

type Silence = amv2.Silence

type SilenceState map[string]*silencepb.MeshSilence

type State interface {
	MarshalBinary() ([]byte, error)
}

type TemplateErrorKind string

type TemplateScope string

type TemplatesProvider interface {
	GetTemplate(kind templates.Kind) (*templates.Template, error)
}

type TestIntegrationConfigResult struct {
	Name   string `json:"name"`
	UID    string `json:"uid"`
	Status string `json:"status"`
	Error  string `json:"error"`
}

type TestReceiverResult struct {
	Name    string                        `json:"name"`
	Configs []TestIntegrationConfigResult `json:"configs"`
}

type TestReceiversConfigBodyParams struct {
	Alert     *models.TestReceiversConfigAlertParams `yaml:"alert,omitempty" json:"alert,omitempty"`
	Receivers []*APIReceiver                         `yaml:"receivers,omitempty" json:"receivers,omitempty"`
}

type TestReceiversResult struct {
	Alert     types.Alert          `json:"alert"`
	Receivers []TestReceiverResult `json:"receivers"`
	NotifedAt time.Time            `json:"notifiedAt"`
}

type TestTemplatesConfigBodyParams struct {
	// Alerts to use as data when testing the template.
	Alerts []*PostableAlert

	// Template string to test.
	Template string

	// Name of the template.
	Name string

	// Kind of template to test. Default is Grafana
	Kind templates.Kind
}

type TestTemplatesErrorResult struct {
	// Name of the associated template for this error. Will be empty if the Kind is "invalid_template".
	Name string `json:"name"`

	// Kind of template error that occurred.
	Kind TemplateErrorKind `json:"kind"`

	// Error cause.
	Error string `json:"error"`
}

type TestTemplatesResult struct {
	// Name of the associated template definition for this result.
	Name string `json:"name"`

	// Interpolated value of the template.
	Text string `json:"text"`

	// Scope that was successfully used to interpolate the template. If the root scope "." fails, more specific
	// scopes will be tried, such as ".Alerts', or ".Alert".
	Scope TemplateScope `json:"scope"`
}

type TestTemplatesResults struct {
	Results []TestTemplatesResult      `json:"results"`
	Errors  []TestTemplatesErrorResult `json:"errors"`
}

type TimeInterval = config.TimeInterval

type WrapNotifierFunc func(integrationName string, notifier nfstatus.Notifier) nfstatus.Notifier