Alerting: Time Intervals API (#88201)

* expose ngalert API to public * add delete action to time-intervals * introduce time-interval model generated by app-platform-sdk from CUE model the fields of the model are chosen to be compatible with the current model * implement api server * add feature flag alertingApiServer ---- Test Infra * update helper to support creating custom users with enterprise permissions * add generator for Interval model
2024-06-20 16:52:03 -04:00
parent 3228b64fe6
commit b075926202
53 changed files with 3149 additions and 54 deletions
@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by applyconfiguration-gen. DO NOT EDIT.
+
+package v0alpha1
+
+// IntervalApplyConfiguration represents an declarative configuration of the Interval type for use
+// with apply.
+type IntervalApplyConfiguration struct {
+	DaysOfMonth []string                      `json:"days_of_month,omitempty"`
+	Location    *string                       `json:"location,omitempty"`
+	Months      []string                      `json:"months,omitempty"`
+	Times       []TimeRangeApplyConfiguration `json:"times,omitempty"`
+	Weekdays    []string                      `json:"weekdays,omitempty"`
+	Years       []string                      `json:"years,omitempty"`
+}
+
+// IntervalApplyConfiguration constructs an declarative configuration of the Interval type for use with
+// apply.
+func Interval() *IntervalApplyConfiguration {
+	return &IntervalApplyConfiguration{}
+}
+
+// WithDaysOfMonth adds the given value to the DaysOfMonth field in the declarative configuration
+// and returns the receiver, so that objects can be build by chaining "With" function invocations.
+// If called multiple times, values provided by each call will be appended to the DaysOfMonth field.
+func (b *IntervalApplyConfiguration) WithDaysOfMonth(values ...string) *IntervalApplyConfiguration {
+	for i := range values {
+		b.DaysOfMonth = append(b.DaysOfMonth, values[i])
+	}
+	return b
+}
+
+// WithLocation sets the Location field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the Location field is set to the value of the last call.
+func (b *IntervalApplyConfiguration) WithLocation(value string) *IntervalApplyConfiguration {
+	b.Location = &value
+	return b
+}
+
+// WithMonths adds the given value to the Months field in the declarative configuration
+// and returns the receiver, so that objects can be build by chaining "With" function invocations.
+// If called multiple times, values provided by each call will be appended to the Months field.
+func (b *IntervalApplyConfiguration) WithMonths(values ...string) *IntervalApplyConfiguration {
+	for i := range values {
+		b.Months = append(b.Months, values[i])
+	}
+	return b
+}
+
+// WithTimes adds the given value to the Times field in the declarative configuration
+// and returns the receiver, so that objects can be build by chaining "With" function invocations.
+// If called multiple times, values provided by each call will be appended to the Times field.
+func (b *IntervalApplyConfiguration) WithTimes(values ...*TimeRangeApplyConfiguration) *IntervalApplyConfiguration {
+	for i := range values {
+		if values[i] == nil {
+			panic("nil value passed to WithTimes")
+		}
+		b.Times = append(b.Times, *values[i])
+	}
+	return b
+}
+
+// WithWeekdays adds the given value to the Weekdays field in the declarative configuration
+// and returns the receiver, so that objects can be build by chaining "With" function invocations.
+// If called multiple times, values provided by each call will be appended to the Weekdays field.
+func (b *IntervalApplyConfiguration) WithWeekdays(values ...string) *IntervalApplyConfiguration {
+	for i := range values {
+		b.Weekdays = append(b.Weekdays, values[i])
+	}
+	return b
+}
+
+// WithYears adds the given value to the Years field in the declarative configuration
+// and returns the receiver, so that objects can be build by chaining "With" function invocations.
+// If called multiple times, values provided by each call will be appended to the Years field.
+func (b *IntervalApplyConfiguration) WithYears(values ...string) *IntervalApplyConfiguration {
+	for i := range values {
+		b.Years = append(b.Years, values[i])
+	}
+	return b
+}
@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by applyconfiguration-gen. DO NOT EDIT.
+
+package v0alpha1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	v1 "k8s.io/client-go/applyconfigurations/meta/v1"
+)
+
+// TimeIntervalApplyConfiguration represents an declarative configuration of the TimeInterval type for use
+// with apply.
+type TimeIntervalApplyConfiguration struct {
+	v1.TypeMetaApplyConfiguration    `json:",inline"`
+	*v1.ObjectMetaApplyConfiguration `json:"metadata,omitempty"`
+	Spec                             *TimeIntervalSpecApplyConfiguration `json:"spec,omitempty"`
+}
+
+// TimeInterval constructs an declarative configuration of the TimeInterval type for use with
+// apply.
+func TimeInterval(name, namespace string) *TimeIntervalApplyConfiguration {
+	b := &TimeIntervalApplyConfiguration{}
+	b.WithName(name)
+	b.WithNamespace(namespace)
+	b.WithKind("TimeInterval")
+	b.WithAPIVersion("notifications.alerting.grafana.app/v0alpha1")
+	return b
+}
+
+// WithKind sets the Kind field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the Kind field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithKind(value string) *TimeIntervalApplyConfiguration {
+	b.Kind = &value
+	return b
+}
+
+// WithAPIVersion sets the APIVersion field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the APIVersion field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithAPIVersion(value string) *TimeIntervalApplyConfiguration {
+	b.APIVersion = &value
+	return b
+}
+
+// WithName sets the Name field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the Name field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithName(value string) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	b.Name = &value
+	return b
+}
+
+// WithGenerateName sets the GenerateName field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the GenerateName field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithGenerateName(value string) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	b.GenerateName = &value
+	return b
+}
+
+// WithNamespace sets the Namespace field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the Namespace field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithNamespace(value string) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	b.Namespace = &value
+	return b
+}
+
+// WithUID sets the UID field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the UID field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithUID(value types.UID) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	b.UID = &value
+	return b
+}
+
+// WithResourceVersion sets the ResourceVersion field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the ResourceVersion field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithResourceVersion(value string) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	b.ResourceVersion = &value
+	return b
+}
+
+// WithGeneration sets the Generation field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the Generation field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithGeneration(value int64) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	b.Generation = &value
+	return b
+}
+
+// WithCreationTimestamp sets the CreationTimestamp field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the CreationTimestamp field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithCreationTimestamp(value metav1.Time) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	b.CreationTimestamp = &value
+	return b
+}
+
+// WithDeletionTimestamp sets the DeletionTimestamp field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the DeletionTimestamp field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithDeletionTimestamp(value metav1.Time) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	b.DeletionTimestamp = &value
+	return b
+}
+
+// WithDeletionGracePeriodSeconds sets the DeletionGracePeriodSeconds field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the DeletionGracePeriodSeconds field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithDeletionGracePeriodSeconds(value int64) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	b.DeletionGracePeriodSeconds = &value
+	return b
+}
+
+// WithLabels puts the entries into the Labels field in the declarative configuration
+// and returns the receiver, so that objects can be build by chaining "With" function invocations.
+// If called multiple times, the entries provided by each call will be put on the Labels field,
+// overwriting an existing map entries in Labels field with the same key.
+func (b *TimeIntervalApplyConfiguration) WithLabels(entries map[string]string) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	if b.Labels == nil && len(entries) > 0 {
+		b.Labels = make(map[string]string, len(entries))
+	}
+	for k, v := range entries {
+		b.Labels[k] = v
+	}
+	return b
+}
+
+// WithAnnotations puts the entries into the Annotations field in the declarative configuration
+// and returns the receiver, so that objects can be build by chaining "With" function invocations.
+// If called multiple times, the entries provided by each call will be put on the Annotations field,
+// overwriting an existing map entries in Annotations field with the same key.
+func (b *TimeIntervalApplyConfiguration) WithAnnotations(entries map[string]string) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	if b.Annotations == nil && len(entries) > 0 {
+		b.Annotations = make(map[string]string, len(entries))
+	}
+	for k, v := range entries {
+		b.Annotations[k] = v
+	}
+	return b
+}
+
+// WithOwnerReferences adds the given value to the OwnerReferences field in the declarative configuration
+// and returns the receiver, so that objects can be build by chaining "With" function invocations.
+// If called multiple times, values provided by each call will be appended to the OwnerReferences field.
+func (b *TimeIntervalApplyConfiguration) WithOwnerReferences(values ...*v1.OwnerReferenceApplyConfiguration) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	for i := range values {
+		if values[i] == nil {
+			panic("nil value passed to WithOwnerReferences")
+		}
+		b.OwnerReferences = append(b.OwnerReferences, *values[i])
+	}
+	return b
+}
+
+// WithFinalizers adds the given value to the Finalizers field in the declarative configuration
+// and returns the receiver, so that objects can be build by chaining "With" function invocations.
+// If called multiple times, values provided by each call will be appended to the Finalizers field.
+func (b *TimeIntervalApplyConfiguration) WithFinalizers(values ...string) *TimeIntervalApplyConfiguration {
+	b.ensureObjectMetaApplyConfigurationExists()
+	for i := range values {
+		b.Finalizers = append(b.Finalizers, values[i])
+	}
+	return b
+}
+
+func (b *TimeIntervalApplyConfiguration) ensureObjectMetaApplyConfigurationExists() {
+	if b.ObjectMetaApplyConfiguration == nil {
+		b.ObjectMetaApplyConfiguration = &v1.ObjectMetaApplyConfiguration{}
+	}
+}
+
+// WithSpec sets the Spec field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the Spec field is set to the value of the last call.
+func (b *TimeIntervalApplyConfiguration) WithSpec(value *TimeIntervalSpecApplyConfiguration) *TimeIntervalApplyConfiguration {
+	b.Spec = value
+	return b
+}
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by applyconfiguration-gen. DO NOT EDIT.
+
+package v0alpha1
+
+// TimeIntervalSpecApplyConfiguration represents an declarative configuration of the TimeIntervalSpec type for use
+// with apply.
+type TimeIntervalSpecApplyConfiguration struct {
+	Name          *string                      `json:"name,omitempty"`
+	TimeIntervals []IntervalApplyConfiguration `json:"time_intervals,omitempty"`
+}
+
+// TimeIntervalSpecApplyConfiguration constructs an declarative configuration of the TimeIntervalSpec type for use with
+// apply.
+func TimeIntervalSpec() *TimeIntervalSpecApplyConfiguration {
+	return &TimeIntervalSpecApplyConfiguration{}
+}
+
+// WithName sets the Name field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the Name field is set to the value of the last call.
+func (b *TimeIntervalSpecApplyConfiguration) WithName(value string) *TimeIntervalSpecApplyConfiguration {
+	b.Name = &value
+	return b
+}
+
+// WithTimeIntervals adds the given value to the TimeIntervals field in the declarative configuration
+// and returns the receiver, so that objects can be build by chaining "With" function invocations.
+// If called multiple times, values provided by each call will be appended to the TimeIntervals field.
+func (b *TimeIntervalSpecApplyConfiguration) WithTimeIntervals(values ...*IntervalApplyConfiguration) *TimeIntervalSpecApplyConfiguration {
+	for i := range values {
+		if values[i] == nil {
+			panic("nil value passed to WithTimeIntervals")
+		}
+		b.TimeIntervals = append(b.TimeIntervals, *values[i])
+	}
+	return b
+}
@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by applyconfiguration-gen. DO NOT EDIT.
+
+package v0alpha1
+
+// TimeRangeApplyConfiguration represents an declarative configuration of the TimeRange type for use
+// with apply.
+type TimeRangeApplyConfiguration struct {
+	EndTime   *string `json:"end_time,omitempty"`
+	StartTime *string `json:"start_time,omitempty"`
+}
+
+// TimeRangeApplyConfiguration constructs an declarative configuration of the TimeRange type for use with
+// apply.
+func TimeRange() *TimeRangeApplyConfiguration {
+	return &TimeRangeApplyConfiguration{}
+}
+
+// WithEndTime sets the EndTime field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the EndTime field is set to the value of the last call.
+func (b *TimeRangeApplyConfiguration) WithEndTime(value string) *TimeRangeApplyConfiguration {
+	b.EndTime = &value
+	return b
+}
+
+// WithStartTime sets the StartTime field in the declarative configuration to the given value
+// and returns the receiver, so that objects can be built by chaining "With" function invocations.
+// If called multiple times, the StartTime field is set to the value of the last call.
+func (b *TimeRangeApplyConfiguration) WithStartTime(value string) *TimeRangeApplyConfiguration {
+	b.StartTime = &value
+	return b
+}
@@ -5,8 +5,10 @@
 package applyconfiguration

 import (
-	v0alpha1 "github.com/grafana/grafana/pkg/apis/service/v0alpha1"
-	servicev0alpha1 "github.com/grafana/grafana/pkg/generated/applyconfiguration/service/v0alpha1"
+	v0alpha1 "github.com/grafana/grafana/pkg/apis/alerting_notifications/v0alpha1"
+	servicev0alpha1 "github.com/grafana/grafana/pkg/apis/service/v0alpha1"
+	alertingnotificationsv0alpha1 "github.com/grafana/grafana/pkg/generated/applyconfiguration/alerting_notifications/v0alpha1"
+	applyconfigurationservicev0alpha1 "github.com/grafana/grafana/pkg/generated/applyconfiguration/service/v0alpha1"
 	schema "k8s.io/apimachinery/pkg/runtime/schema"
 )

@@ -14,11 +16,21 @@ import (
 // apply configuration type exists for the given GroupVersionKind.
 func ForKind(kind schema.GroupVersionKind) interface{} {
 	switch kind {
-	// Group=service.grafana.app, Version=v0alpha1
-	case v0alpha1.SchemeGroupVersion.WithKind("ExternalName"):
-		return &servicev0alpha1.ExternalNameApplyConfiguration{}
-	case v0alpha1.SchemeGroupVersion.WithKind("ExternalNameSpec"):
-		return &servicev0alpha1.ExternalNameSpecApplyConfiguration{}
+	// Group=notifications.alerting.grafana.app, Version=v0alpha1
+	case v0alpha1.SchemeGroupVersion.WithKind("Interval"):
+		return &alertingnotificationsv0alpha1.IntervalApplyConfiguration{}
+	case v0alpha1.SchemeGroupVersion.WithKind("TimeInterval"):
+		return &alertingnotificationsv0alpha1.TimeIntervalApplyConfiguration{}
+	case v0alpha1.SchemeGroupVersion.WithKind("TimeIntervalSpec"):
+		return &alertingnotificationsv0alpha1.TimeIntervalSpecApplyConfiguration{}
+	case v0alpha1.SchemeGroupVersion.WithKind("TimeRange"):
+		return &alertingnotificationsv0alpha1.TimeRangeApplyConfiguration{}
+
+		// Group=service.grafana.app, Version=v0alpha1
+	case servicev0alpha1.SchemeGroupVersion.WithKind("ExternalName"):
+		return &applyconfigurationservicev0alpha1.ExternalNameApplyConfiguration{}
+	case servicev0alpha1.SchemeGroupVersion.WithKind("ExternalNameSpec"):
+		return &applyconfigurationservicev0alpha1.ExternalNameSpecApplyConfiguration{}

 	}
 	return nil
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"net/http"

+	notificationsv0alpha1 "github.com/grafana/grafana/pkg/generated/clientset/versioned/typed/alerting_notifications/v0alpha1"
 	servicev0alpha1 "github.com/grafana/grafana/pkg/generated/clientset/versioned/typed/service/v0alpha1"
 	discovery "k8s.io/client-go/discovery"
 	rest "k8s.io/client-go/rest"
@@ -16,13 +17,20 @@ import (

 type Interface interface {
 	Discovery() discovery.DiscoveryInterface
+	NotificationsV0alpha1() notificationsv0alpha1.NotificationsV0alpha1Interface
 	ServiceV0alpha1() servicev0alpha1.ServiceV0alpha1Interface
 }

 // Clientset contains the clients for groups.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	serviceV0alpha1 *servicev0alpha1.ServiceV0alpha1Client
+	notificationsV0alpha1 *notificationsv0alpha1.NotificationsV0alpha1Client
+	serviceV0alpha1       *servicev0alpha1.ServiceV0alpha1Client
+}
+
+// NotificationsV0alpha1 retrieves the NotificationsV0alpha1Client
+func (c *Clientset) NotificationsV0alpha1() notificationsv0alpha1.NotificationsV0alpha1Interface {
+	return c.notificationsV0alpha1
 }

 // ServiceV0alpha1 retrieves the ServiceV0alpha1Client
@@ -74,6 +82,10 @@ func NewForConfigAndClient(c *rest.Config, httpClient *http.Client) (*Clientset,

 	var cs Clientset
 	var err error
+	cs.notificationsV0alpha1, err = notificationsv0alpha1.NewForConfigAndClient(&configShallowCopy, httpClient)
+	if err != nil {
+		return nil, err
+	}
 	cs.serviceV0alpha1, err = servicev0alpha1.NewForConfigAndClient(&configShallowCopy, httpClient)
 	if err != nil {
 		return nil, err
@@ -99,6 +111,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
+	cs.notificationsV0alpha1 = notificationsv0alpha1.New(c)
 	cs.serviceV0alpha1 = servicev0alpha1.New(c)

 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
@@ -6,6 +6,8 @@ package fake

 import (
 	clientset "github.com/grafana/grafana/pkg/generated/clientset/versioned"
+	notificationsv0alpha1 "github.com/grafana/grafana/pkg/generated/clientset/versioned/typed/alerting_notifications/v0alpha1"
+	fakenotificationsv0alpha1 "github.com/grafana/grafana/pkg/generated/clientset/versioned/typed/alerting_notifications/v0alpha1/fake"
 	servicev0alpha1 "github.com/grafana/grafana/pkg/generated/clientset/versioned/typed/service/v0alpha1"
 	fakeservicev0alpha1 "github.com/grafana/grafana/pkg/generated/clientset/versioned/typed/service/v0alpha1/fake"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -65,6 +67,11 @@ var (
 	_ testing.FakeClient  = &Clientset{}
 )

+// NotificationsV0alpha1 retrieves the NotificationsV0alpha1Client
+func (c *Clientset) NotificationsV0alpha1() notificationsv0alpha1.NotificationsV0alpha1Interface {
+	return &fakenotificationsv0alpha1.FakeNotificationsV0alpha1{Fake: &c.Fake}
+}
+
 // ServiceV0alpha1 retrieves the ServiceV0alpha1Client
 func (c *Clientset) ServiceV0alpha1() servicev0alpha1.ServiceV0alpha1Interface {
 	return &fakeservicev0alpha1.FakeServiceV0alpha1{Fake: &c.Fake}
@@ -5,6 +5,7 @@
 package fake

 import (
+	notificationsv0alpha1 "github.com/grafana/grafana/pkg/apis/alerting_notifications/v0alpha1"
 	servicev0alpha1 "github.com/grafana/grafana/pkg/apis/service/v0alpha1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
@@ -17,6 +18,7 @@ var scheme = runtime.NewScheme()
 var codecs = serializer.NewCodecFactory(scheme)

 var localSchemeBuilder = runtime.SchemeBuilder{
+	notificationsv0alpha1.AddToScheme,
 	servicev0alpha1.AddToScheme,
 }

@@ -5,6 +5,7 @@
 package scheme

 import (
+	notificationsv0alpha1 "github.com/grafana/grafana/pkg/apis/alerting_notifications/v0alpha1"
 	servicev0alpha1 "github.com/grafana/grafana/pkg/apis/service/v0alpha1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
@@ -17,6 +18,7 @@ var Scheme = runtime.NewScheme()
 var Codecs = serializer.NewCodecFactory(Scheme)
 var ParameterCodec = runtime.NewParameterCodec(Scheme)
 var localSchemeBuilder = runtime.SchemeBuilder{
+	notificationsv0alpha1.AddToScheme,
 	servicev0alpha1.AddToScheme,
 }

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v0alpha1
+
+import (
+	"net/http"
+
+	v0alpha1 "github.com/grafana/grafana/pkg/apis/alerting_notifications/v0alpha1"
+	"github.com/grafana/grafana/pkg/generated/clientset/versioned/scheme"
+	rest "k8s.io/client-go/rest"
+)
+
+type NotificationsV0alpha1Interface interface {
+	RESTClient() rest.Interface
+	TimeIntervalsGetter
+}
+
+// NotificationsV0alpha1Client is used to interact with features provided by the notifications.alerting.grafana.app group.
+type NotificationsV0alpha1Client struct {
+	restClient rest.Interface
+}
+
+func (c *NotificationsV0alpha1Client) TimeIntervals(namespace string) TimeIntervalInterface {
+	return newTimeIntervals(c, namespace)
+}
+
+// NewForConfig creates a new NotificationsV0alpha1Client for the given config.
+// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient),
+// where httpClient was generated with rest.HTTPClientFor(c).
+func NewForConfig(c *rest.Config) (*NotificationsV0alpha1Client, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	httpClient, err := rest.HTTPClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return NewForConfigAndClient(&config, httpClient)
+}
+
+// NewForConfigAndClient creates a new NotificationsV0alpha1Client for the given config and http client.
+// Note the http client provided takes precedence over the configured transport values.
+func NewForConfigAndClient(c *rest.Config, h *http.Client) (*NotificationsV0alpha1Client, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.RESTClientForConfigAndClient(&config, h)
+	if err != nil {
+		return nil, err
+	}
+	return &NotificationsV0alpha1Client{client}, nil
+}
+
+// NewForConfigOrDie creates a new NotificationsV0alpha1Client for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *NotificationsV0alpha1Client {
+	client, err := NewForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+// New creates a new NotificationsV0alpha1Client for the given RESTClient.
+func New(c rest.Interface) *NotificationsV0alpha1Client {
+	return &NotificationsV0alpha1Client{c}
+}
+
+func setConfigDefaults(config *rest.Config) error {
+	gv := v0alpha1.SchemeGroupVersion
+	config.GroupVersion = &gv
+	config.APIPath = "/apis"
+	config.NegotiatedSerializer = scheme.Codecs.WithoutConversion()
+
+	if config.UserAgent == "" {
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+
+	return nil
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *NotificationsV0alpha1Client) RESTClient() rest.Interface {
+	if c == nil {
+		return nil
+	}
+	return c.restClient
+}
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// This package has the automatically generated typed clients.
+package v0alpha1
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// Package fake has the automatically generated clients.
+package fake
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v0alpha1 "github.com/grafana/grafana/pkg/generated/clientset/versioned/typed/alerting_notifications/v0alpha1"
+	rest "k8s.io/client-go/rest"
+	testing "k8s.io/client-go/testing"
+)
+
+type FakeNotificationsV0alpha1 struct {
+	*testing.Fake
+}
+
+func (c *FakeNotificationsV0alpha1) TimeIntervals(namespace string) v0alpha1.TimeIntervalInterface {
+	return &FakeTimeIntervals{c, namespace}
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeNotificationsV0alpha1) RESTClient() rest.Interface {
+	var ret *rest.RESTClient
+	return ret
+}
@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	"context"
+	json "encoding/json"
+	"fmt"
+
+	v0alpha1 "github.com/grafana/grafana/pkg/apis/alerting_notifications/v0alpha1"
+	alertingnotificationsv0alpha1 "github.com/grafana/grafana/pkg/generated/applyconfiguration/alerting_notifications/v0alpha1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakeTimeIntervals implements TimeIntervalInterface
+type FakeTimeIntervals struct {
+	Fake *FakeNotificationsV0alpha1
+	ns   string
+}
+
+var timeintervalsResource = v0alpha1.SchemeGroupVersion.WithResource("timeintervals")
+
+var timeintervalsKind = v0alpha1.SchemeGroupVersion.WithKind("TimeInterval")
+
+// Get takes name of the timeInterval, and returns the corresponding timeInterval object, and an error if there is any.
+func (c *FakeTimeIntervals) Get(ctx context.Context, name string, options v1.GetOptions) (result *v0alpha1.TimeInterval, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewGetAction(timeintervalsResource, c.ns, name), &v0alpha1.TimeInterval{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v0alpha1.TimeInterval), err
+}
+
+// List takes label and field selectors, and returns the list of TimeIntervals that match those selectors.
+func (c *FakeTimeIntervals) List(ctx context.Context, opts v1.ListOptions) (result *v0alpha1.TimeIntervalList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewListAction(timeintervalsResource, timeintervalsKind, c.ns, opts), &v0alpha1.TimeIntervalList{})
+
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v0alpha1.TimeIntervalList{ListMeta: obj.(*v0alpha1.TimeIntervalList).ListMeta}
+	for _, item := range obj.(*v0alpha1.TimeIntervalList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested timeIntervals.
+func (c *FakeTimeIntervals) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewWatchAction(timeintervalsResource, c.ns, opts))
+
+}
+
+// Create takes the representation of a timeInterval and creates it.  Returns the server's representation of the timeInterval, and an error, if there is any.
+func (c *FakeTimeIntervals) Create(ctx context.Context, timeInterval *v0alpha1.TimeInterval, opts v1.CreateOptions) (result *v0alpha1.TimeInterval, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewCreateAction(timeintervalsResource, c.ns, timeInterval), &v0alpha1.TimeInterval{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v0alpha1.TimeInterval), err
+}
+
+// Update takes the representation of a timeInterval and updates it. Returns the server's representation of the timeInterval, and an error, if there is any.
+func (c *FakeTimeIntervals) Update(ctx context.Context, timeInterval *v0alpha1.TimeInterval, opts v1.UpdateOptions) (result *v0alpha1.TimeInterval, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewUpdateAction(timeintervalsResource, c.ns, timeInterval), &v0alpha1.TimeInterval{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v0alpha1.TimeInterval), err
+}
+
+// Delete takes name of the timeInterval and deletes it. Returns an error if one occurs.
+func (c *FakeTimeIntervals) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewDeleteActionWithOptions(timeintervalsResource, c.ns, name, opts), &v0alpha1.TimeInterval{})
+
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakeTimeIntervals) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	action := testing.NewDeleteCollectionAction(timeintervalsResource, c.ns, listOpts)
+
+	_, err := c.Fake.Invokes(action, &v0alpha1.TimeIntervalList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched timeInterval.
+func (c *FakeTimeIntervals) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v0alpha1.TimeInterval, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(timeintervalsResource, c.ns, name, pt, data, subresources...), &v0alpha1.TimeInterval{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v0alpha1.TimeInterval), err
+}
+
+// Apply takes the given apply declarative configuration, applies it and returns the applied timeInterval.
+func (c *FakeTimeIntervals) Apply(ctx context.Context, timeInterval *alertingnotificationsv0alpha1.TimeIntervalApplyConfiguration, opts v1.ApplyOptions) (result *v0alpha1.TimeInterval, err error) {
+	if timeInterval == nil {
+		return nil, fmt.Errorf("timeInterval provided to Apply must not be nil")
+	}
+	data, err := json.Marshal(timeInterval)
+	if err != nil {
+		return nil, err
+	}
+	name := timeInterval.Name
+	if name == nil {
+		return nil, fmt.Errorf("timeInterval.Name must be provided to Apply")
+	}
+	obj, err := c.Fake.
+		Invokes(testing.NewPatchSubresourceAction(timeintervalsResource, c.ns, *name, types.ApplyPatchType, data), &v0alpha1.TimeInterval{})
+
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v0alpha1.TimeInterval), err
+}
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v0alpha1
+
+type TimeIntervalExpansion interface{}
@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v0alpha1
+
+import (
+	"context"
+	json "encoding/json"
+	"fmt"
+	"time"
+
+	v0alpha1 "github.com/grafana/grafana/pkg/apis/alerting_notifications/v0alpha1"
+	alertingnotificationsv0alpha1 "github.com/grafana/grafana/pkg/generated/applyconfiguration/alerting_notifications/v0alpha1"
+	scheme "github.com/grafana/grafana/pkg/generated/clientset/versioned/scheme"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	rest "k8s.io/client-go/rest"
+)
+
+// TimeIntervalsGetter has a method to return a TimeIntervalInterface.
+// A group's client should implement this interface.
+type TimeIntervalsGetter interface {
+	TimeIntervals(namespace string) TimeIntervalInterface
+}
+
+// TimeIntervalInterface has methods to work with TimeInterval resources.
+type TimeIntervalInterface interface {
+	Create(ctx context.Context, timeInterval *v0alpha1.TimeInterval, opts v1.CreateOptions) (*v0alpha1.TimeInterval, error)
+	Update(ctx context.Context, timeInterval *v0alpha1.TimeInterval, opts v1.UpdateOptions) (*v0alpha1.TimeInterval, error)
+	Delete(ctx context.Context, name string, opts v1.DeleteOptions) error
+	DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error
+	Get(ctx context.Context, name string, opts v1.GetOptions) (*v0alpha1.TimeInterval, error)
+	List(ctx context.Context, opts v1.ListOptions) (*v0alpha1.TimeIntervalList, error)
+	Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)
+	Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v0alpha1.TimeInterval, err error)
+	Apply(ctx context.Context, timeInterval *alertingnotificationsv0alpha1.TimeIntervalApplyConfiguration, opts v1.ApplyOptions) (result *v0alpha1.TimeInterval, err error)
+	TimeIntervalExpansion
+}
+
+// timeIntervals implements TimeIntervalInterface
+type timeIntervals struct {
+	client rest.Interface
+	ns     string
+}
+
+// newTimeIntervals returns a TimeIntervals
+func newTimeIntervals(c *NotificationsV0alpha1Client, namespace string) *timeIntervals {
+	return &timeIntervals{
+		client: c.RESTClient(),
+		ns:     namespace,
+	}
+}
+
+// Get takes name of the timeInterval, and returns the corresponding timeInterval object, and an error if there is any.
+func (c *timeIntervals) Get(ctx context.Context, name string, options v1.GetOptions) (result *v0alpha1.TimeInterval, err error) {
+	result = &v0alpha1.TimeInterval{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("timeintervals").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of TimeIntervals that match those selectors.
+func (c *timeIntervals) List(ctx context.Context, opts v1.ListOptions) (result *v0alpha1.TimeIntervalList, err error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	result = &v0alpha1.TimeIntervalList{}
+	err = c.client.Get().
+		Namespace(c.ns).
+		Resource("timeintervals").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested timeIntervals.
+func (c *timeIntervals) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
+	var timeout time.Duration
+	if opts.TimeoutSeconds != nil {
+		timeout = time.Duration(*opts.TimeoutSeconds) * time.Second
+	}
+	opts.Watch = true
+	return c.client.Get().
+		Namespace(c.ns).
+		Resource("timeintervals").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Watch(ctx)
+}
+
+// Create takes the representation of a timeInterval and creates it.  Returns the server's representation of the timeInterval, and an error, if there is any.
+func (c *timeIntervals) Create(ctx context.Context, timeInterval *v0alpha1.TimeInterval, opts v1.CreateOptions) (result *v0alpha1.TimeInterval, err error) {
+	result = &v0alpha1.TimeInterval{}
+	err = c.client.Post().
+		Namespace(c.ns).
+		Resource("timeintervals").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Body(timeInterval).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// Update takes the representation of a timeInterval and updates it. Returns the server's representation of the timeInterval, and an error, if there is any.
+func (c *timeIntervals) Update(ctx context.Context, timeInterval *v0alpha1.TimeInterval, opts v1.UpdateOptions) (result *v0alpha1.TimeInterval, err error) {
+	result = &v0alpha1.TimeInterval{}
+	err = c.client.Put().
+		Namespace(c.ns).
+		Resource("timeintervals").
+		Name(timeInterval.Name).
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Body(timeInterval).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// Delete takes name of the timeInterval and deletes it. Returns an error if one occurs.
+func (c *timeIntervals) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("timeintervals").
+		Name(name).
+		Body(&opts).
+		Do(ctx).
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *timeIntervals) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
+	var timeout time.Duration
+	if listOpts.TimeoutSeconds != nil {
+		timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second
+	}
+	return c.client.Delete().
+		Namespace(c.ns).
+		Resource("timeintervals").
+		VersionedParams(&listOpts, scheme.ParameterCodec).
+		Timeout(timeout).
+		Body(&opts).
+		Do(ctx).
+		Error()
+}
+
+// Patch applies the patch and returns the patched timeInterval.
+func (c *timeIntervals) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v0alpha1.TimeInterval, err error) {
+	result = &v0alpha1.TimeInterval{}
+	err = c.client.Patch(pt).
+		Namespace(c.ns).
+		Resource("timeintervals").
+		Name(name).
+		SubResource(subresources...).
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Body(data).
+		Do(ctx).
+		Into(result)
+	return
+}
+
+// Apply takes the given apply declarative configuration, applies it and returns the applied timeInterval.
+func (c *timeIntervals) Apply(ctx context.Context, timeInterval *alertingnotificationsv0alpha1.TimeIntervalApplyConfiguration, opts v1.ApplyOptions) (result *v0alpha1.TimeInterval, err error) {
+	if timeInterval == nil {
+		return nil, fmt.Errorf("timeInterval provided to Apply must not be nil")
+	}
+	patchOpts := opts.ToPatchOptions()
+	data, err := json.Marshal(timeInterval)
+	if err != nil {
+		return nil, err
+	}
+	name := timeInterval.Name
+	if name == nil {
+		return nil, fmt.Errorf("timeInterval.Name must be provided to Apply")
+	}
+	result = &v0alpha1.TimeInterval{}
+	err = c.client.Patch(types.ApplyPatchType).
+		Namespace(c.ns).
+		Resource("timeintervals").
+		Name(*name).
+		VersionedParams(&patchOpts, scheme.ParameterCodec).
+		Body(data).
+		Do(ctx).
+		Into(result)
+	return
+}
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package alerting_notifications
+
+import (
+	v0alpha1 "github.com/grafana/grafana/pkg/generated/informers/externalversions/alerting_notifications/v0alpha1"
+	internalinterfaces "github.com/grafana/grafana/pkg/generated/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V0alpha1 provides access to shared informers for resources in V0alpha1.
+	V0alpha1() v0alpha1.Interface
+}
+
+type group struct {
+	factory          internalinterfaces.SharedInformerFactory
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
+	return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
+}
+
+// V0alpha1 returns a new v0alpha1.Interface.
+func (g *group) V0alpha1() v0alpha1.Interface {
+	return v0alpha1.New(g.factory, g.namespace, g.tweakListOptions)
+}
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v0alpha1
+
+import (
+	internalinterfaces "github.com/grafana/grafana/pkg/generated/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// TimeIntervals returns a TimeIntervalInformer.
+	TimeIntervals() TimeIntervalInformer
+}
+
+type version struct {
+	factory          internalinterfaces.SharedInformerFactory
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
+	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
+}
+
+// TimeIntervals returns a TimeIntervalInformer.
+func (v *version) TimeIntervals() TimeIntervalInformer {
+	return &timeIntervalInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v0alpha1
+
+import (
+	"context"
+	time "time"
+
+	alertingnotificationsv0alpha1 "github.com/grafana/grafana/pkg/apis/alerting_notifications/v0alpha1"
+	versioned "github.com/grafana/grafana/pkg/generated/clientset/versioned"
+	internalinterfaces "github.com/grafana/grafana/pkg/generated/informers/externalversions/internalinterfaces"
+	v0alpha1 "github.com/grafana/grafana/pkg/generated/listers/alerting_notifications/v0alpha1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	watch "k8s.io/apimachinery/pkg/watch"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+// TimeIntervalInformer provides access to a shared informer and lister for
+// TimeIntervals.
+type TimeIntervalInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v0alpha1.TimeIntervalLister
+}
+
+type timeIntervalInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewTimeIntervalInformer constructs a new informer for TimeInterval type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewTimeIntervalInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredTimeIntervalInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredTimeIntervalInformer constructs a new informer for TimeInterval type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewFilteredTimeIntervalInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
+	return cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.NotificationsV0alpha1().TimeIntervals(namespace).List(context.TODO(), options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.NotificationsV0alpha1().TimeIntervals(namespace).Watch(context.TODO(), options)
+			},
+		},
+		&alertingnotificationsv0alpha1.TimeInterval{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *timeIntervalInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredTimeIntervalInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *timeIntervalInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&alertingnotificationsv0alpha1.TimeInterval{}, f.defaultInformer)
+}
+
+func (f *timeIntervalInformer) Lister() v0alpha1.TimeIntervalLister {
+	return v0alpha1.NewTimeIntervalLister(f.Informer().GetIndexer())
+}
@@ -10,6 +10,7 @@ import (
 	time "time"

 	versioned "github.com/grafana/grafana/pkg/generated/clientset/versioned"
+	alertingnotifications "github.com/grafana/grafana/pkg/generated/informers/externalversions/alerting_notifications"
 	internalinterfaces "github.com/grafana/grafana/pkg/generated/informers/externalversions/internalinterfaces"
 	service "github.com/grafana/grafana/pkg/generated/informers/externalversions/service"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -239,9 +240,14 @@ type SharedInformerFactory interface {
 	// client.
 	InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer

+	Notifications() alertingnotifications.Interface
 	Service() service.Interface
 }

+func (f *sharedInformerFactory) Notifications() alertingnotifications.Interface {
+	return alertingnotifications.New(f, f.namespace, f.tweakListOptions)
+}
+
 func (f *sharedInformerFactory) Service() service.Interface {
 	return service.New(f, f.namespace, f.tweakListOptions)
 }
@@ -7,7 +7,8 @@ package externalversions
 import (
 	"fmt"

-	v0alpha1 "github.com/grafana/grafana/pkg/apis/service/v0alpha1"
+	v0alpha1 "github.com/grafana/grafana/pkg/apis/alerting_notifications/v0alpha1"
+	servicev0alpha1 "github.com/grafana/grafana/pkg/apis/service/v0alpha1"
 	schema "k8s.io/apimachinery/pkg/runtime/schema"
 	cache "k8s.io/client-go/tools/cache"
 )
@@ -38,8 +39,12 @@ func (f *genericInformer) Lister() cache.GenericLister {
 // TODO extend this to unknown resources with a client pool
 func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) {
 	switch resource {
-	// Group=service.grafana.app, Version=v0alpha1
-	case v0alpha1.SchemeGroupVersion.WithResource("externalnames"):
+	// Group=notifications.alerting.grafana.app, Version=v0alpha1
+	case v0alpha1.SchemeGroupVersion.WithResource("timeintervals"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Notifications().V0alpha1().TimeIntervals().Informer()}, nil
+
+		// Group=service.grafana.app, Version=v0alpha1
+	case servicev0alpha1.SchemeGroupVersion.WithResource("externalnames"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Service().V0alpha1().ExternalNames().Informer()}, nil

 	}
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package v0alpha1
+
+// TimeIntervalListerExpansion allows custom methods to be added to
+// TimeIntervalLister.
+type TimeIntervalListerExpansion interface{}
+
+// TimeIntervalNamespaceListerExpansion allows custom methods to be added to
+// TimeIntervalNamespaceLister.
+type TimeIntervalNamespaceListerExpansion interface{}
@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// Code generated by lister-gen. DO NOT EDIT.
+
+package v0alpha1
+
+import (
+	v0alpha1 "github.com/grafana/grafana/pkg/apis/alerting_notifications/v0alpha1"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/client-go/tools/cache"
+)
+
+// TimeIntervalLister helps list TimeIntervals.
+// All objects returned here must be treated as read-only.
+type TimeIntervalLister interface {
+	// List lists all TimeIntervals in the indexer.
+	// Objects returned here must be treated as read-only.
+	List(selector labels.Selector) (ret []*v0alpha1.TimeInterval, err error)
+	// TimeIntervals returns an object that can list and get TimeIntervals.
+	TimeIntervals(namespace string) TimeIntervalNamespaceLister
+	TimeIntervalListerExpansion
+}
+
+// timeIntervalLister implements the TimeIntervalLister interface.
+type timeIntervalLister struct {
+	indexer cache.Indexer
+}
+
+// NewTimeIntervalLister returns a new TimeIntervalLister.
+func NewTimeIntervalLister(indexer cache.Indexer) TimeIntervalLister {
+	return &timeIntervalLister{indexer: indexer}
+}
+
+// List lists all TimeIntervals in the indexer.
+func (s *timeIntervalLister) List(selector labels.Selector) (ret []*v0alpha1.TimeInterval, err error) {
+	err = cache.ListAll(s.indexer, selector, func(m interface{}) {
+		ret = append(ret, m.(*v0alpha1.TimeInterval))
+	})
+	return ret, err
+}
+
+// TimeIntervals returns an object that can list and get TimeIntervals.
+func (s *timeIntervalLister) TimeIntervals(namespace string) TimeIntervalNamespaceLister {
+	return timeIntervalNamespaceLister{indexer: s.indexer, namespace: namespace}
+}
+
+// TimeIntervalNamespaceLister helps list and get TimeIntervals.
+// All objects returned here must be treated as read-only.
+type TimeIntervalNamespaceLister interface {
+	// List lists all TimeIntervals in the indexer for a given namespace.
+	// Objects returned here must be treated as read-only.
+	List(selector labels.Selector) (ret []*v0alpha1.TimeInterval, err error)
+	// Get retrieves the TimeInterval from the indexer for a given namespace and name.
+	// Objects returned here must be treated as read-only.
+	Get(name string) (*v0alpha1.TimeInterval, error)
+	TimeIntervalNamespaceListerExpansion
+}
+
+// timeIntervalNamespaceLister implements the TimeIntervalNamespaceLister
+// interface.
+type timeIntervalNamespaceLister struct {
+	indexer   cache.Indexer
+	namespace string
+}
+
+// List lists all TimeIntervals in the indexer for a given namespace.
+func (s timeIntervalNamespaceLister) List(selector labels.Selector) (ret []*v0alpha1.TimeInterval, err error) {
+	err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
+		ret = append(ret, m.(*v0alpha1.TimeInterval))
+	})
+	return ret, err
+}
+
+// Get retrieves the TimeInterval from the indexer for a given namespace and name.
+func (s timeIntervalNamespaceLister) Get(name string) (*v0alpha1.TimeInterval, error) {
+	obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
+	if err != nil {
+		return nil, err
+	}
+	if !exists {
+		return nil, errors.NewNotFound(v0alpha1.Resource("timeinterval"), name)
+	}
+	return obj.(*v0alpha1.TimeInterval), nil
+}