http

type Arguments struct {
	TLS *TLSArguments `alloy:"tls,block,optional"`
}

type ClientAuth tls.ClientAuthType

type Component interface {
	component.Component

	// Handler should return a valid HTTP handler for the component.
	// All requests to the component will have the path trimmed such that the component is at the root.
	// For example, f a request is made to `/component/{id}/metrics`, the component
	// will receive a request to just `/metrics`.
	Handler() http.Handler
}

type Data struct {
	// Address that the HTTP service is configured to listen on.
	HTTPListenAddr string

	// Address that the HTTP service is configured to listen on for in-memory
	// traffic when [DialFunc] is used to establish a connection.
	MemoryListenAddr string

	// BaseHTTPPath is the base path where component HTTP routes are exposed.
	BaseHTTPPath string

	// DialFunc is a function which establishes in-memory network connection when
	// address is MemoryListenAddr. If address is not MemoryListenAddr, DialFunc
	// establishes an outbound network connection.
	DialFunc func(ctx context.Context, network, address string) (net.Conn, error)
}

type Options struct {
	Logger   log.Logger           // Where to send logs.
	Tracer   trace.TracerProvider // Where to send traces.
	Gatherer prometheus.Gatherer  // Where to collect metrics from.

	ReadyFunc  func() bool
	ReloadFunc func() (*alloy.Source, error)

	HTTPListenAddr   string // Address to listen for HTTP traffic on.
	MemoryListenAddr string // Address to accept in-memory traffic on.
	EnablePProf      bool   // Whether pprof endpoints should be exposed.
}

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

type ServiceHandler interface {
	service.Service

	// ServiceHandler returns the base route and HTTP handlers to register for
	// the provided service.
	//
	// This method is only called for services that declare a dependency on
	// the http service.
	//
	// The http service prioritizes longer base routes. Given two base routes of
	// /foo and /foo/bar, an HTTP URL of /foo/bar/baz will be routed to the
	// longer base route (/foo/bar).
	ServiceHandler(host service.Host) (base string, handler http.Handler)
}

type TLSArguments struct {
	Cert             string            `alloy:"cert_pem,attr,optional"`
	CertFile         string            `alloy:"cert_file,attr,optional"`
	Key              alloytypes.Secret `alloy:"key_pem,attr,optional"`
	KeyFile          string            `alloy:"key_file,attr,optional"`
	ClientCA         string            `alloy:"client_ca_pem,attr,optional"`
	ClientCAFile     string            `alloy:"client_ca_file,attr,optional"`
	ClientAuth       ClientAuth        `alloy:"client_auth_type,attr,optional"`
	CipherSuites     []TLSCipher       `alloy:"cipher_suites,attr,optional"`
	CurvePreferences []TLSCurve        `alloy:"curve_preferences,attr,optional"`
	MinVersion       TLSVersion        `alloy:"min_version,attr,optional"`
	MaxVersion       TLSVersion        `alloy:"max_version,attr,optional"`

	// Windows Certificate Filter
	WindowsFilter *WindowsCertificateFilter `alloy:"windows_certificate_filter,block,optional"`
}

type TLSCipher uint16

type TLSCurve tls.CurveID

type TLSVersion uint16

type WindowsCertificateFilter struct {
	Server *WindowsServerFilter `alloy:"server,block"`
	Client *WindowsClientFilter `alloy:"client,block"`
}

type WindowsClientFilter struct {
	IssuerCommonNames []string `alloy:"issuer_common_names,attr,optional"`
	SubjectRegEx      string   `alloy:"subject_regex,attr,optional"`
	TemplateID        string   `alloy:"template_id,attr,optional"`
}

type WindowsServerFilter struct {
	Store             string        `alloy:"store,attr,optional"`
	SystemStore       string        `alloy:"system_store,attr,optional"`
	IssuerCommonNames []string      `alloy:"issuer_common_names,attr,optional"`
	TemplateID        string        `alloy:"template_id,attr,optional"`
	RefreshInterval   time.Duration `alloy:"refresh_interval,attr,optional"`
}