use istio client-go library instead of knative (#1661)

use istio client-go library instead of knative
bump kubernetes dependency version
change code coverage to codecov

vendor/istio.io/client-go/pkg/informers/externalversions/authentication/interface.gen.go

@@ -0,0 +1,30 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package authentication
+
+import (
+	v1alpha1 "istio.io/client-go/pkg/informers/externalversions/authentication/v1alpha1"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1alpha1 provides access to shared informers for resources in V1alpha1.
+	V1alpha1() v1alpha1.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}
+}
+
+// V1alpha1 returns a new v1alpha1.Interface.
+func (g *group) V1alpha1() v1alpha1.Interface {
+	return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)
+}

vendor/istio.io/client-go/pkg/informers/externalversions/authentication/v1alpha1/interface.gen.go

@@ -0,0 +1,36 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// MeshPolicies returns a MeshPolicyInformer.
+	MeshPolicies() MeshPolicyInformer
+	// Policies returns a PolicyInformer.
+	Policies() PolicyInformer
+}
+
+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}
+}
+
+// MeshPolicies returns a MeshPolicyInformer.
+func (v *version) MeshPolicies() MeshPolicyInformer {
+	return &meshPolicyInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
+}
+
+// Policies returns a PolicyInformer.
+func (v *version) Policies() PolicyInformer {
+	return &policyInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}

vendor/istio.io/client-go/pkg/informers/externalversions/authentication/v1alpha1/meshpolicy.gen.go

@@ -0,0 +1,72 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	time "time"
+
+	authenticationv1alpha1 "istio.io/client-go/pkg/apis/authentication/v1alpha1"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha1 "istio.io/client-go/pkg/listers/authentication/v1alpha1"
+	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"
+)
+
+// MeshPolicyInformer provides access to a shared informer and lister for
+// MeshPolicies.
+type MeshPolicyInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha1.MeshPolicyLister
+}
+
+type meshPolicyInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// NewMeshPolicyInformer constructs a new informer for MeshPolicy 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 NewMeshPolicyInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredMeshPolicyInformer(client, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredMeshPolicyInformer constructs a new informer for MeshPolicy 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 NewFilteredMeshPolicyInformer(client versioned.Interface, 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.AuthenticationV1alpha1().MeshPolicies().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.AuthenticationV1alpha1().MeshPolicies().Watch(options)
+			},
+		},
+		&authenticationv1alpha1.MeshPolicy{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *meshPolicyInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredMeshPolicyInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *meshPolicyInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&authenticationv1alpha1.MeshPolicy{}, f.defaultInformer)
+}
+
+func (f *meshPolicyInformer) Lister() v1alpha1.MeshPolicyLister {
+	return v1alpha1.NewMeshPolicyLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/authentication/v1alpha1/policy.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	time "time"
+
+	authenticationv1alpha1 "istio.io/client-go/pkg/apis/authentication/v1alpha1"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha1 "istio.io/client-go/pkg/listers/authentication/v1alpha1"
+	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"
+)
+
+// PolicyInformer provides access to a shared informer and lister for
+// Policies.
+type PolicyInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha1.PolicyLister
+}
+
+type policyInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewPolicyInformer constructs a new informer for Policy 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 NewPolicyInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredPolicyInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredPolicyInformer constructs a new informer for Policy 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 NewFilteredPolicyInformer(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.AuthenticationV1alpha1().Policies(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.AuthenticationV1alpha1().Policies(namespace).Watch(options)
+			},
+		},
+		&authenticationv1alpha1.Policy{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *policyInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredPolicyInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *policyInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&authenticationv1alpha1.Policy{}, f.defaultInformer)
+}
+
+func (f *policyInformer) Lister() v1alpha1.PolicyLister {
+	return v1alpha1.NewPolicyLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/config/interface.gen.go

@@ -0,0 +1,30 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package config
+
+import (
+	v1alpha2 "istio.io/client-go/pkg/informers/externalversions/config/v1alpha2"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1alpha2 provides access to shared informers for resources in V1alpha2.
+	V1alpha2() v1alpha2.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}
+}
+
+// V1alpha2 returns a new v1alpha2.Interface.
+func (g *group) V1alpha2() v1alpha2.Interface {
+	return v1alpha2.New(g.factory, g.namespace, g.tweakListOptions)
+}

vendor/istio.io/client-go/pkg/informers/externalversions/config/v1alpha2/attributemanifest.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	time "time"
+
+	configv1alpha2 "istio.io/client-go/pkg/apis/config/v1alpha2"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha2 "istio.io/client-go/pkg/listers/config/v1alpha2"
+	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"
+)
+
+// AttributeManifestInformer provides access to a shared informer and lister for
+// AttributeManifests.
+type AttributeManifestInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha2.AttributeManifestLister
+}
+
+type attributeManifestInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewAttributeManifestInformer constructs a new informer for AttributeManifest 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 NewAttributeManifestInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredAttributeManifestInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredAttributeManifestInformer constructs a new informer for AttributeManifest 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 NewFilteredAttributeManifestInformer(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.ConfigV1alpha2().AttributeManifests(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ConfigV1alpha2().AttributeManifests(namespace).Watch(options)
+			},
+		},
+		&configv1alpha2.AttributeManifest{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *attributeManifestInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredAttributeManifestInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *attributeManifestInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&configv1alpha2.AttributeManifest{}, f.defaultInformer)
+}
+
+func (f *attributeManifestInformer) Lister() v1alpha2.AttributeManifestLister {
+	return v1alpha2.NewAttributeManifestLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/config/v1alpha2/handler.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	time "time"
+
+	configv1alpha2 "istio.io/client-go/pkg/apis/config/v1alpha2"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha2 "istio.io/client-go/pkg/listers/config/v1alpha2"
+	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"
+)
+
+// HandlerInformer provides access to a shared informer and lister for
+// Handlers.
+type HandlerInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha2.HandlerLister
+}
+
+type handlerInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewHandlerInformer constructs a new informer for Handler 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 NewHandlerInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredHandlerInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredHandlerInformer constructs a new informer for Handler 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 NewFilteredHandlerInformer(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.ConfigV1alpha2().Handlers(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ConfigV1alpha2().Handlers(namespace).Watch(options)
+			},
+		},
+		&configv1alpha2.Handler{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *handlerInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredHandlerInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *handlerInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&configv1alpha2.Handler{}, f.defaultInformer)
+}
+
+func (f *handlerInformer) Lister() v1alpha2.HandlerLister {
+	return v1alpha2.NewHandlerLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/config/v1alpha2/httpapispec.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	time "time"
+
+	configv1alpha2 "istio.io/client-go/pkg/apis/config/v1alpha2"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha2 "istio.io/client-go/pkg/listers/config/v1alpha2"
+	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"
+)
+
+// HTTPAPISpecInformer provides access to a shared informer and lister for
+// HTTPAPISpecs.
+type HTTPAPISpecInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha2.HTTPAPISpecLister
+}
+
+type hTTPAPISpecInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewHTTPAPISpecInformer constructs a new informer for HTTPAPISpec 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 NewHTTPAPISpecInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredHTTPAPISpecInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredHTTPAPISpecInformer constructs a new informer for HTTPAPISpec 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 NewFilteredHTTPAPISpecInformer(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.ConfigV1alpha2().HTTPAPISpecs(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ConfigV1alpha2().HTTPAPISpecs(namespace).Watch(options)
+			},
+		},
+		&configv1alpha2.HTTPAPISpec{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *hTTPAPISpecInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredHTTPAPISpecInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *hTTPAPISpecInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&configv1alpha2.HTTPAPISpec{}, f.defaultInformer)
+}
+
+func (f *hTTPAPISpecInformer) Lister() v1alpha2.HTTPAPISpecLister {
+	return v1alpha2.NewHTTPAPISpecLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/config/v1alpha2/httpapispecbinding.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	time "time"
+
+	configv1alpha2 "istio.io/client-go/pkg/apis/config/v1alpha2"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha2 "istio.io/client-go/pkg/listers/config/v1alpha2"
+	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"
+)
+
+// HTTPAPISpecBindingInformer provides access to a shared informer and lister for
+// HTTPAPISpecBindings.
+type HTTPAPISpecBindingInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha2.HTTPAPISpecBindingLister
+}
+
+type hTTPAPISpecBindingInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewHTTPAPISpecBindingInformer constructs a new informer for HTTPAPISpecBinding 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 NewHTTPAPISpecBindingInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredHTTPAPISpecBindingInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredHTTPAPISpecBindingInformer constructs a new informer for HTTPAPISpecBinding 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 NewFilteredHTTPAPISpecBindingInformer(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.ConfigV1alpha2().HTTPAPISpecBindings(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ConfigV1alpha2().HTTPAPISpecBindings(namespace).Watch(options)
+			},
+		},
+		&configv1alpha2.HTTPAPISpecBinding{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *hTTPAPISpecBindingInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredHTTPAPISpecBindingInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *hTTPAPISpecBindingInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&configv1alpha2.HTTPAPISpecBinding{}, f.defaultInformer)
+}
+
+func (f *hTTPAPISpecBindingInformer) Lister() v1alpha2.HTTPAPISpecBindingLister {
+	return v1alpha2.NewHTTPAPISpecBindingLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/config/v1alpha2/instance.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	time "time"
+
+	configv1alpha2 "istio.io/client-go/pkg/apis/config/v1alpha2"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha2 "istio.io/client-go/pkg/listers/config/v1alpha2"
+	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"
+)
+
+// InstanceInformer provides access to a shared informer and lister for
+// Instances.
+type InstanceInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha2.InstanceLister
+}
+
+type instanceInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewInstanceInformer constructs a new informer for Instance 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 NewInstanceInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredInstanceInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredInstanceInformer constructs a new informer for Instance 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 NewFilteredInstanceInformer(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.ConfigV1alpha2().Instances(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ConfigV1alpha2().Instances(namespace).Watch(options)
+			},
+		},
+		&configv1alpha2.Instance{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *instanceInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredInstanceInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *instanceInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&configv1alpha2.Instance{}, f.defaultInformer)
+}
+
+func (f *instanceInformer) Lister() v1alpha2.InstanceLister {
+	return v1alpha2.NewInstanceLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/config/v1alpha2/interface.gen.go

@@ -0,0 +1,78 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// AttributeManifests returns a AttributeManifestInformer.
+	AttributeManifests() AttributeManifestInformer
+	// HTTPAPISpecs returns a HTTPAPISpecInformer.
+	HTTPAPISpecs() HTTPAPISpecInformer
+	// HTTPAPISpecBindings returns a HTTPAPISpecBindingInformer.
+	HTTPAPISpecBindings() HTTPAPISpecBindingInformer
+	// Handlers returns a HandlerInformer.
+	Handlers() HandlerInformer
+	// Instances returns a InstanceInformer.
+	Instances() InstanceInformer
+	// QuotaSpecs returns a QuotaSpecInformer.
+	QuotaSpecs() QuotaSpecInformer
+	// QuotaSpecBindings returns a QuotaSpecBindingInformer.
+	QuotaSpecBindings() QuotaSpecBindingInformer
+	// Rules returns a RuleInformer.
+	Rules() RuleInformer
+}
+
+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}
+}
+
+// AttributeManifests returns a AttributeManifestInformer.
+func (v *version) AttributeManifests() AttributeManifestInformer {
+	return &attributeManifestInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// HTTPAPISpecs returns a HTTPAPISpecInformer.
+func (v *version) HTTPAPISpecs() HTTPAPISpecInformer {
+	return &hTTPAPISpecInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// HTTPAPISpecBindings returns a HTTPAPISpecBindingInformer.
+func (v *version) HTTPAPISpecBindings() HTTPAPISpecBindingInformer {
+	return &hTTPAPISpecBindingInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// Handlers returns a HandlerInformer.
+func (v *version) Handlers() HandlerInformer {
+	return &handlerInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// Instances returns a InstanceInformer.
+func (v *version) Instances() InstanceInformer {
+	return &instanceInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// QuotaSpecs returns a QuotaSpecInformer.
+func (v *version) QuotaSpecs() QuotaSpecInformer {
+	return &quotaSpecInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// QuotaSpecBindings returns a QuotaSpecBindingInformer.
+func (v *version) QuotaSpecBindings() QuotaSpecBindingInformer {
+	return &quotaSpecBindingInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// Rules returns a RuleInformer.
+func (v *version) Rules() RuleInformer {
+	return &ruleInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}

vendor/istio.io/client-go/pkg/informers/externalversions/config/v1alpha2/quotaspec.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	time "time"
+
+	configv1alpha2 "istio.io/client-go/pkg/apis/config/v1alpha2"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha2 "istio.io/client-go/pkg/listers/config/v1alpha2"
+	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"
+)
+
+// QuotaSpecInformer provides access to a shared informer and lister for
+// QuotaSpecs.
+type QuotaSpecInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha2.QuotaSpecLister
+}
+
+type quotaSpecInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewQuotaSpecInformer constructs a new informer for QuotaSpec 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 NewQuotaSpecInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredQuotaSpecInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredQuotaSpecInformer constructs a new informer for QuotaSpec 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 NewFilteredQuotaSpecInformer(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.ConfigV1alpha2().QuotaSpecs(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ConfigV1alpha2().QuotaSpecs(namespace).Watch(options)
+			},
+		},
+		&configv1alpha2.QuotaSpec{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *quotaSpecInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredQuotaSpecInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *quotaSpecInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&configv1alpha2.QuotaSpec{}, f.defaultInformer)
+}
+
+func (f *quotaSpecInformer) Lister() v1alpha2.QuotaSpecLister {
+	return v1alpha2.NewQuotaSpecLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/config/v1alpha2/quotaspecbinding.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	time "time"
+
+	configv1alpha2 "istio.io/client-go/pkg/apis/config/v1alpha2"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha2 "istio.io/client-go/pkg/listers/config/v1alpha2"
+	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"
+)
+
+// QuotaSpecBindingInformer provides access to a shared informer and lister for
+// QuotaSpecBindings.
+type QuotaSpecBindingInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha2.QuotaSpecBindingLister
+}
+
+type quotaSpecBindingInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewQuotaSpecBindingInformer constructs a new informer for QuotaSpecBinding 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 NewQuotaSpecBindingInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredQuotaSpecBindingInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredQuotaSpecBindingInformer constructs a new informer for QuotaSpecBinding 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 NewFilteredQuotaSpecBindingInformer(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.ConfigV1alpha2().QuotaSpecBindings(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ConfigV1alpha2().QuotaSpecBindings(namespace).Watch(options)
+			},
+		},
+		&configv1alpha2.QuotaSpecBinding{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *quotaSpecBindingInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredQuotaSpecBindingInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *quotaSpecBindingInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&configv1alpha2.QuotaSpecBinding{}, f.defaultInformer)
+}
+
+func (f *quotaSpecBindingInformer) Lister() v1alpha2.QuotaSpecBindingLister {
+	return v1alpha2.NewQuotaSpecBindingLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/config/v1alpha2/rule.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha2
+
+import (
+	time "time"
+
+	configv1alpha2 "istio.io/client-go/pkg/apis/config/v1alpha2"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha2 "istio.io/client-go/pkg/listers/config/v1alpha2"
+	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"
+)
+
+// RuleInformer provides access to a shared informer and lister for
+// Rules.
+type RuleInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha2.RuleLister
+}
+
+type ruleInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewRuleInformer constructs a new informer for Rule 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 NewRuleInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredRuleInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredRuleInformer constructs a new informer for Rule 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 NewFilteredRuleInformer(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.ConfigV1alpha2().Rules(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.ConfigV1alpha2().Rules(namespace).Watch(options)
+			},
+		},
+		&configv1alpha2.Rule{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *ruleInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredRuleInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *ruleInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&configv1alpha2.Rule{}, f.defaultInformer)
+}
+
+func (f *ruleInformer) Lister() v1alpha2.RuleLister {
+	return v1alpha2.NewRuleLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/factory.gen.go

@@ -0,0 +1,188 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package externalversions
+
+import (
+	reflect "reflect"
+	sync "sync"
+	time "time"
+
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	authentication "istio.io/client-go/pkg/informers/externalversions/authentication"
+	config "istio.io/client-go/pkg/informers/externalversions/config"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	networking "istio.io/client-go/pkg/informers/externalversions/networking"
+	rbac "istio.io/client-go/pkg/informers/externalversions/rbac"
+	security "istio.io/client-go/pkg/informers/externalversions/security"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+// SharedInformerOption defines the functional option type for SharedInformerFactory.
+type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory
+
+type sharedInformerFactory struct {
+	client           versioned.Interface
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	lock             sync.Mutex
+	defaultResync    time.Duration
+	customResync     map[reflect.Type]time.Duration
+
+	informers map[reflect.Type]cache.SharedIndexInformer
+	// startedInformers is used for tracking which informers have been started.
+	// This allows Start() to be called multiple times safely.
+	startedInformers map[reflect.Type]bool
+}
+
+// WithCustomResyncConfig sets a custom resync period for the specified informer types.
+func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		for k, v := range resyncConfig {
+			factory.customResync[reflect.TypeOf(k)] = v
+		}
+		return factory
+	}
+}
+
+// WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory.
+func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		factory.tweakListOptions = tweakListOptions
+		return factory
+	}
+}
+
+// WithNamespace limits the SharedInformerFactory to the specified namespace.
+func WithNamespace(namespace string) SharedInformerOption {
+	return func(factory *sharedInformerFactory) *sharedInformerFactory {
+		factory.namespace = namespace
+		return factory
+	}
+}
+
+// NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces.
+func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory {
+	return NewSharedInformerFactoryWithOptions(client, defaultResync)
+}
+
+// NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory.
+// Listers obtained via this SharedInformerFactory will be subject to the same filters
+// as specified here.
+// Deprecated: Please use NewSharedInformerFactoryWithOptions instead
+func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory {
+	return NewSharedInformerFactoryWithOptions(client, defaultResync, WithNamespace(namespace), WithTweakListOptions(tweakListOptions))
+}
+
+// NewSharedInformerFactoryWithOptions constructs a new instance of a SharedInformerFactory with additional options.
+func NewSharedInformerFactoryWithOptions(client versioned.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory {
+	factory := &sharedInformerFactory{
+		client:           client,
+		namespace:        v1.NamespaceAll,
+		defaultResync:    defaultResync,
+		informers:        make(map[reflect.Type]cache.SharedIndexInformer),
+		startedInformers: make(map[reflect.Type]bool),
+		customResync:     make(map[reflect.Type]time.Duration),
+	}
+
+	// Apply all options
+	for _, opt := range options {
+		factory = opt(factory)
+	}
+
+	return factory
+}
+
+// Start initializes all requested informers.
+func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	for informerType, informer := range f.informers {
+		if !f.startedInformers[informerType] {
+			go informer.Run(stopCh)
+			f.startedInformers[informerType] = true
+		}
+	}
+}
+
+// WaitForCacheSync waits for all started informers' cache were synced.
+func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool {
+	informers := func() map[reflect.Type]cache.SharedIndexInformer {
+		f.lock.Lock()
+		defer f.lock.Unlock()
+
+		informers := map[reflect.Type]cache.SharedIndexInformer{}
+		for informerType, informer := range f.informers {
+			if f.startedInformers[informerType] {
+				informers[informerType] = informer
+			}
+		}
+		return informers
+	}()
+
+	res := map[reflect.Type]bool{}
+	for informType, informer := range informers {
+		res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced)
+	}
+	return res
+}
+
+// InternalInformerFor returns the SharedIndexInformer for obj using an internal
+// client.
+func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	informerType := reflect.TypeOf(obj)
+	informer, exists := f.informers[informerType]
+	if exists {
+		return informer
+	}
+
+	resyncPeriod, exists := f.customResync[informerType]
+	if !exists {
+		resyncPeriod = f.defaultResync
+	}
+
+	informer = newFunc(f.client, resyncPeriod)
+	f.informers[informerType] = informer
+
+	return informer
+}
+
+// SharedInformerFactory provides shared informers for resources in all known
+// API group versions.
+type SharedInformerFactory interface {
+	internalinterfaces.SharedInformerFactory
+	ForResource(resource schema.GroupVersionResource) (GenericInformer, error)
+	WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool
+
+	Authentication() authentication.Interface
+	Config() config.Interface
+	Networking() networking.Interface
+	Rbac() rbac.Interface
+	Security() security.Interface
+}
+
+func (f *sharedInformerFactory) Authentication() authentication.Interface {
+	return authentication.New(f, f.namespace, f.tweakListOptions)
+}
+
+func (f *sharedInformerFactory) Config() config.Interface {
+	return config.New(f, f.namespace, f.tweakListOptions)
+}
+
+func (f *sharedInformerFactory) Networking() networking.Interface {
+	return networking.New(f, f.namespace, f.tweakListOptions)
+}
+
+func (f *sharedInformerFactory) Rbac() rbac.Interface {
+	return rbac.New(f, f.namespace, f.tweakListOptions)
+}
+
+func (f *sharedInformerFactory) Security() security.Interface {
+	return security.New(f, f.namespace, f.tweakListOptions)
+}

vendor/istio.io/client-go/pkg/informers/externalversions/generic.gen.go

@@ -0,0 +1,98 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package externalversions
+
+import (
+	"fmt"
+
+	v1alpha1 "istio.io/client-go/pkg/apis/authentication/v1alpha1"
+	v1alpha2 "istio.io/client-go/pkg/apis/config/v1alpha2"
+	v1alpha3 "istio.io/client-go/pkg/apis/networking/v1alpha3"
+	rbacv1alpha1 "istio.io/client-go/pkg/apis/rbac/v1alpha1"
+	v1beta1 "istio.io/client-go/pkg/apis/security/v1beta1"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+// GenericInformer is type of SharedIndexInformer which will locate and delegate to other
+// sharedInformers based on type
+type GenericInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() cache.GenericLister
+}
+
+type genericInformer struct {
+	informer cache.SharedIndexInformer
+	resource schema.GroupResource
+}
+
+// Informer returns the SharedIndexInformer.
+func (f *genericInformer) Informer() cache.SharedIndexInformer {
+	return f.informer
+}
+
+// Lister returns the GenericLister.
+func (f *genericInformer) Lister() cache.GenericLister {
+	return cache.NewGenericLister(f.Informer().GetIndexer(), f.resource)
+}
+
+// ForResource gives generic access to a shared informer of the matching type
+// TODO extend this to unknown resources with a client pool
+func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) {
+	switch resource {
+	// Group=authentication, Version=v1alpha1
+	case v1alpha1.SchemeGroupVersion.WithResource("meshpolicies"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Authentication().V1alpha1().MeshPolicies().Informer()}, nil
+	case v1alpha1.SchemeGroupVersion.WithResource("policies"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Authentication().V1alpha1().Policies().Informer()}, nil
+
+		// Group=config, Version=v1alpha2
+	case v1alpha2.SchemeGroupVersion.WithResource("attributemanifests"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1alpha2().AttributeManifests().Informer()}, nil
+	case v1alpha2.SchemeGroupVersion.WithResource("httpapispecs"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1alpha2().HTTPAPISpecs().Informer()}, nil
+	case v1alpha2.SchemeGroupVersion.WithResource("httpapispecbindings"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1alpha2().HTTPAPISpecBindings().Informer()}, nil
+	case v1alpha2.SchemeGroupVersion.WithResource("handlers"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1alpha2().Handlers().Informer()}, nil
+	case v1alpha2.SchemeGroupVersion.WithResource("instances"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1alpha2().Instances().Informer()}, nil
+	case v1alpha2.SchemeGroupVersion.WithResource("quotaspecs"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1alpha2().QuotaSpecs().Informer()}, nil
+	case v1alpha2.SchemeGroupVersion.WithResource("quotaspecbindings"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1alpha2().QuotaSpecBindings().Informer()}, nil
+	case v1alpha2.SchemeGroupVersion.WithResource("rules"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Config().V1alpha2().Rules().Informer()}, nil
+
+		// Group=networking, Version=v1alpha3
+	case v1alpha3.SchemeGroupVersion.WithResource("destinationrules"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Networking().V1alpha3().DestinationRules().Informer()}, nil
+	case v1alpha3.SchemeGroupVersion.WithResource("envoyfilters"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Networking().V1alpha3().EnvoyFilters().Informer()}, nil
+	case v1alpha3.SchemeGroupVersion.WithResource("gateways"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Networking().V1alpha3().Gateways().Informer()}, nil
+	case v1alpha3.SchemeGroupVersion.WithResource("serviceentries"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Networking().V1alpha3().ServiceEntries().Informer()}, nil
+	case v1alpha3.SchemeGroupVersion.WithResource("sidecars"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Networking().V1alpha3().Sidecars().Informer()}, nil
+	case v1alpha3.SchemeGroupVersion.WithResource("virtualservices"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Networking().V1alpha3().VirtualServices().Informer()}, nil
+
+		// Group=rbac, Version=v1alpha1
+	case rbacv1alpha1.SchemeGroupVersion.WithResource("clusterrbacconfigs"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1alpha1().ClusterRbacConfigs().Informer()}, nil
+	case rbacv1alpha1.SchemeGroupVersion.WithResource("rbacconfigs"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1alpha1().RbacConfigs().Informer()}, nil
+	case rbacv1alpha1.SchemeGroupVersion.WithResource("serviceroles"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1alpha1().ServiceRoles().Informer()}, nil
+	case rbacv1alpha1.SchemeGroupVersion.WithResource("servicerolebindings"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1alpha1().ServiceRoleBindings().Informer()}, nil
+
+		// Group=security, Version=v1beta1
+	case v1beta1.SchemeGroupVersion.WithResource("authorizationpolicies"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Security().V1beta1().AuthorizationPolicies().Informer()}, nil
+
+	}
+
+	return nil, fmt.Errorf("no informer found for %v", resource)
+}

vendor/istio.io/client-go/pkg/informers/externalversions/internalinterfaces/factory_interfaces.gen.go

@@ -0,0 +1,24 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package internalinterfaces
+
+import (
+	time "time"
+
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+// NewInformerFunc takes versioned.Interface and time.Duration to return a SharedIndexInformer.
+type NewInformerFunc func(versioned.Interface, time.Duration) cache.SharedIndexInformer
+
+// SharedInformerFactory a small interface to allow for adding an informer without an import cycle
+type SharedInformerFactory interface {
+	Start(stopCh <-chan struct{})
+	InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer
+}
+
+// TweakListOptionsFunc is a function that transforms a v1.ListOptions.
+type TweakListOptionsFunc func(*v1.ListOptions)

vendor/istio.io/client-go/pkg/informers/externalversions/networking/interface.gen.go

@@ -0,0 +1,30 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package networking
+
+import (
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha3 "istio.io/client-go/pkg/informers/externalversions/networking/v1alpha3"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1alpha3 provides access to shared informers for resources in V1alpha3.
+	V1alpha3() v1alpha3.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}
+}
+
+// V1alpha3 returns a new v1alpha3.Interface.
+func (g *group) V1alpha3() v1alpha3.Interface {
+	return v1alpha3.New(g.factory, g.namespace, g.tweakListOptions)
+}

vendor/istio.io/client-go/pkg/informers/externalversions/networking/v1alpha3/destinationrule.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha3
+
+import (
+	time "time"
+
+	networkingv1alpha3 "istio.io/client-go/pkg/apis/networking/v1alpha3"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha3 "istio.io/client-go/pkg/listers/networking/v1alpha3"
+	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"
+)
+
+// DestinationRuleInformer provides access to a shared informer and lister for
+// DestinationRules.
+type DestinationRuleInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha3.DestinationRuleLister
+}
+
+type destinationRuleInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewDestinationRuleInformer constructs a new informer for DestinationRule 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 NewDestinationRuleInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredDestinationRuleInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredDestinationRuleInformer constructs a new informer for DestinationRule 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 NewFilteredDestinationRuleInformer(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.NetworkingV1alpha3().DestinationRules(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.NetworkingV1alpha3().DestinationRules(namespace).Watch(options)
+			},
+		},
+		&networkingv1alpha3.DestinationRule{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *destinationRuleInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredDestinationRuleInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *destinationRuleInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&networkingv1alpha3.DestinationRule{}, f.defaultInformer)
+}
+
+func (f *destinationRuleInformer) Lister() v1alpha3.DestinationRuleLister {
+	return v1alpha3.NewDestinationRuleLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/networking/v1alpha3/envoyfilter.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha3
+
+import (
+	time "time"
+
+	networkingv1alpha3 "istio.io/client-go/pkg/apis/networking/v1alpha3"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha3 "istio.io/client-go/pkg/listers/networking/v1alpha3"
+	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"
+)
+
+// EnvoyFilterInformer provides access to a shared informer and lister for
+// EnvoyFilters.
+type EnvoyFilterInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha3.EnvoyFilterLister
+}
+
+type envoyFilterInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewEnvoyFilterInformer constructs a new informer for EnvoyFilter 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 NewEnvoyFilterInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredEnvoyFilterInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredEnvoyFilterInformer constructs a new informer for EnvoyFilter 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 NewFilteredEnvoyFilterInformer(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.NetworkingV1alpha3().EnvoyFilters(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.NetworkingV1alpha3().EnvoyFilters(namespace).Watch(options)
+			},
+		},
+		&networkingv1alpha3.EnvoyFilter{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *envoyFilterInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredEnvoyFilterInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *envoyFilterInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&networkingv1alpha3.EnvoyFilter{}, f.defaultInformer)
+}
+
+func (f *envoyFilterInformer) Lister() v1alpha3.EnvoyFilterLister {
+	return v1alpha3.NewEnvoyFilterLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/networking/v1alpha3/gateway.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha3
+
+import (
+	time "time"
+
+	networkingv1alpha3 "istio.io/client-go/pkg/apis/networking/v1alpha3"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha3 "istio.io/client-go/pkg/listers/networking/v1alpha3"
+	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"
+)
+
+// GatewayInformer provides access to a shared informer and lister for
+// Gateways.
+type GatewayInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha3.GatewayLister
+}
+
+type gatewayInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewGatewayInformer constructs a new informer for Gateway 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 NewGatewayInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredGatewayInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredGatewayInformer constructs a new informer for Gateway 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 NewFilteredGatewayInformer(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.NetworkingV1alpha3().Gateways(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.NetworkingV1alpha3().Gateways(namespace).Watch(options)
+			},
+		},
+		&networkingv1alpha3.Gateway{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *gatewayInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredGatewayInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *gatewayInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&networkingv1alpha3.Gateway{}, f.defaultInformer)
+}
+
+func (f *gatewayInformer) Lister() v1alpha3.GatewayLister {
+	return v1alpha3.NewGatewayLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/networking/v1alpha3/interface.gen.go

@@ -0,0 +1,64 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha3
+
+import (
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// DestinationRules returns a DestinationRuleInformer.
+	DestinationRules() DestinationRuleInformer
+	// EnvoyFilters returns a EnvoyFilterInformer.
+	EnvoyFilters() EnvoyFilterInformer
+	// Gateways returns a GatewayInformer.
+	Gateways() GatewayInformer
+	// ServiceEntries returns a ServiceEntryInformer.
+	ServiceEntries() ServiceEntryInformer
+	// Sidecars returns a SidecarInformer.
+	Sidecars() SidecarInformer
+	// VirtualServices returns a VirtualServiceInformer.
+	VirtualServices() VirtualServiceInformer
+}
+
+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}
+}
+
+// DestinationRules returns a DestinationRuleInformer.
+func (v *version) DestinationRules() DestinationRuleInformer {
+	return &destinationRuleInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// EnvoyFilters returns a EnvoyFilterInformer.
+func (v *version) EnvoyFilters() EnvoyFilterInformer {
+	return &envoyFilterInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// Gateways returns a GatewayInformer.
+func (v *version) Gateways() GatewayInformer {
+	return &gatewayInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// ServiceEntries returns a ServiceEntryInformer.
+func (v *version) ServiceEntries() ServiceEntryInformer {
+	return &serviceEntryInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// Sidecars returns a SidecarInformer.
+func (v *version) Sidecars() SidecarInformer {
+	return &sidecarInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// VirtualServices returns a VirtualServiceInformer.
+func (v *version) VirtualServices() VirtualServiceInformer {
+	return &virtualServiceInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}

vendor/istio.io/client-go/pkg/informers/externalversions/networking/v1alpha3/serviceentry.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha3
+
+import (
+	time "time"
+
+	networkingv1alpha3 "istio.io/client-go/pkg/apis/networking/v1alpha3"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha3 "istio.io/client-go/pkg/listers/networking/v1alpha3"
+	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"
+)
+
+// ServiceEntryInformer provides access to a shared informer and lister for
+// ServiceEntries.
+type ServiceEntryInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha3.ServiceEntryLister
+}
+
+type serviceEntryInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewServiceEntryInformer constructs a new informer for ServiceEntry 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 NewServiceEntryInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredServiceEntryInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredServiceEntryInformer constructs a new informer for ServiceEntry 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 NewFilteredServiceEntryInformer(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.NetworkingV1alpha3().ServiceEntries(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.NetworkingV1alpha3().ServiceEntries(namespace).Watch(options)
+			},
+		},
+		&networkingv1alpha3.ServiceEntry{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *serviceEntryInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredServiceEntryInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *serviceEntryInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&networkingv1alpha3.ServiceEntry{}, f.defaultInformer)
+}
+
+func (f *serviceEntryInformer) Lister() v1alpha3.ServiceEntryLister {
+	return v1alpha3.NewServiceEntryLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/networking/v1alpha3/sidecar.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha3
+
+import (
+	time "time"
+
+	networkingv1alpha3 "istio.io/client-go/pkg/apis/networking/v1alpha3"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha3 "istio.io/client-go/pkg/listers/networking/v1alpha3"
+	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"
+)
+
+// SidecarInformer provides access to a shared informer and lister for
+// Sidecars.
+type SidecarInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha3.SidecarLister
+}
+
+type sidecarInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewSidecarInformer constructs a new informer for Sidecar 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 NewSidecarInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredSidecarInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredSidecarInformer constructs a new informer for Sidecar 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 NewFilteredSidecarInformer(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.NetworkingV1alpha3().Sidecars(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.NetworkingV1alpha3().Sidecars(namespace).Watch(options)
+			},
+		},
+		&networkingv1alpha3.Sidecar{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *sidecarInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredSidecarInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *sidecarInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&networkingv1alpha3.Sidecar{}, f.defaultInformer)
+}
+
+func (f *sidecarInformer) Lister() v1alpha3.SidecarLister {
+	return v1alpha3.NewSidecarLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/networking/v1alpha3/virtualservice.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha3
+
+import (
+	time "time"
+
+	networkingv1alpha3 "istio.io/client-go/pkg/apis/networking/v1alpha3"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha3 "istio.io/client-go/pkg/listers/networking/v1alpha3"
+	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"
+)
+
+// VirtualServiceInformer provides access to a shared informer and lister for
+// VirtualServices.
+type VirtualServiceInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha3.VirtualServiceLister
+}
+
+type virtualServiceInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewVirtualServiceInformer constructs a new informer for VirtualService 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 NewVirtualServiceInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredVirtualServiceInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredVirtualServiceInformer constructs a new informer for VirtualService 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 NewFilteredVirtualServiceInformer(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.NetworkingV1alpha3().VirtualServices(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.NetworkingV1alpha3().VirtualServices(namespace).Watch(options)
+			},
+		},
+		&networkingv1alpha3.VirtualService{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *virtualServiceInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredVirtualServiceInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *virtualServiceInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&networkingv1alpha3.VirtualService{}, f.defaultInformer)
+}
+
+func (f *virtualServiceInformer) Lister() v1alpha3.VirtualServiceLister {
+	return v1alpha3.NewVirtualServiceLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/rbac/interface.gen.go

@@ -0,0 +1,30 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package rbac
+
+import (
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha1 "istio.io/client-go/pkg/informers/externalversions/rbac/v1alpha1"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1alpha1 provides access to shared informers for resources in V1alpha1.
+	V1alpha1() v1alpha1.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}
+}
+
+// V1alpha1 returns a new v1alpha1.Interface.
+func (g *group) V1alpha1() v1alpha1.Interface {
+	return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)
+}

vendor/istio.io/client-go/pkg/informers/externalversions/rbac/v1alpha1/clusterrbacconfig.gen.go

@@ -0,0 +1,72 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	time "time"
+
+	rbacv1alpha1 "istio.io/client-go/pkg/apis/rbac/v1alpha1"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha1 "istio.io/client-go/pkg/listers/rbac/v1alpha1"
+	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"
+)
+
+// ClusterRbacConfigInformer provides access to a shared informer and lister for
+// ClusterRbacConfigs.
+type ClusterRbacConfigInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha1.ClusterRbacConfigLister
+}
+
+type clusterRbacConfigInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// NewClusterRbacConfigInformer constructs a new informer for ClusterRbacConfig 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 NewClusterRbacConfigInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredClusterRbacConfigInformer(client, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredClusterRbacConfigInformer constructs a new informer for ClusterRbacConfig 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 NewFilteredClusterRbacConfigInformer(client versioned.Interface, 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.RbacV1alpha1().ClusterRbacConfigs().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.RbacV1alpha1().ClusterRbacConfigs().Watch(options)
+			},
+		},
+		&rbacv1alpha1.ClusterRbacConfig{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *clusterRbacConfigInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredClusterRbacConfigInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *clusterRbacConfigInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&rbacv1alpha1.ClusterRbacConfig{}, f.defaultInformer)
+}
+
+func (f *clusterRbacConfigInformer) Lister() v1alpha1.ClusterRbacConfigLister {
+	return v1alpha1.NewClusterRbacConfigLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/rbac/v1alpha1/interface.gen.go

@@ -0,0 +1,50 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// ClusterRbacConfigs returns a ClusterRbacConfigInformer.
+	ClusterRbacConfigs() ClusterRbacConfigInformer
+	// RbacConfigs returns a RbacConfigInformer.
+	RbacConfigs() RbacConfigInformer
+	// ServiceRoles returns a ServiceRoleInformer.
+	ServiceRoles() ServiceRoleInformer
+	// ServiceRoleBindings returns a ServiceRoleBindingInformer.
+	ServiceRoleBindings() ServiceRoleBindingInformer
+}
+
+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}
+}
+
+// ClusterRbacConfigs returns a ClusterRbacConfigInformer.
+func (v *version) ClusterRbacConfigs() ClusterRbacConfigInformer {
+	return &clusterRbacConfigInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
+}
+
+// RbacConfigs returns a RbacConfigInformer.
+func (v *version) RbacConfigs() RbacConfigInformer {
+	return &rbacConfigInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// ServiceRoles returns a ServiceRoleInformer.
+func (v *version) ServiceRoles() ServiceRoleInformer {
+	return &serviceRoleInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}
+
+// ServiceRoleBindings returns a ServiceRoleBindingInformer.
+func (v *version) ServiceRoleBindings() ServiceRoleBindingInformer {
+	return &serviceRoleBindingInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}

vendor/istio.io/client-go/pkg/informers/externalversions/rbac/v1alpha1/rbacconfig.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	time "time"
+
+	rbacv1alpha1 "istio.io/client-go/pkg/apis/rbac/v1alpha1"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha1 "istio.io/client-go/pkg/listers/rbac/v1alpha1"
+	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"
+)
+
+// RbacConfigInformer provides access to a shared informer and lister for
+// RbacConfigs.
+type RbacConfigInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha1.RbacConfigLister
+}
+
+type rbacConfigInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewRbacConfigInformer constructs a new informer for RbacConfig 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 NewRbacConfigInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredRbacConfigInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredRbacConfigInformer constructs a new informer for RbacConfig 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 NewFilteredRbacConfigInformer(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.RbacV1alpha1().RbacConfigs(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.RbacV1alpha1().RbacConfigs(namespace).Watch(options)
+			},
+		},
+		&rbacv1alpha1.RbacConfig{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *rbacConfigInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredRbacConfigInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *rbacConfigInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&rbacv1alpha1.RbacConfig{}, f.defaultInformer)
+}
+
+func (f *rbacConfigInformer) Lister() v1alpha1.RbacConfigLister {
+	return v1alpha1.NewRbacConfigLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/rbac/v1alpha1/servicerole.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	time "time"
+
+	rbacv1alpha1 "istio.io/client-go/pkg/apis/rbac/v1alpha1"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha1 "istio.io/client-go/pkg/listers/rbac/v1alpha1"
+	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"
+)
+
+// ServiceRoleInformer provides access to a shared informer and lister for
+// ServiceRoles.
+type ServiceRoleInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha1.ServiceRoleLister
+}
+
+type serviceRoleInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewServiceRoleInformer constructs a new informer for ServiceRole 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 NewServiceRoleInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredServiceRoleInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredServiceRoleInformer constructs a new informer for ServiceRole 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 NewFilteredServiceRoleInformer(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.RbacV1alpha1().ServiceRoles(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.RbacV1alpha1().ServiceRoles(namespace).Watch(options)
+			},
+		},
+		&rbacv1alpha1.ServiceRole{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *serviceRoleInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredServiceRoleInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *serviceRoleInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&rbacv1alpha1.ServiceRole{}, f.defaultInformer)
+}
+
+func (f *serviceRoleInformer) Lister() v1alpha1.ServiceRoleLister {
+	return v1alpha1.NewServiceRoleLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/rbac/v1alpha1/servicerolebinding.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	time "time"
+
+	rbacv1alpha1 "istio.io/client-go/pkg/apis/rbac/v1alpha1"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1alpha1 "istio.io/client-go/pkg/listers/rbac/v1alpha1"
+	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"
+)
+
+// ServiceRoleBindingInformer provides access to a shared informer and lister for
+// ServiceRoleBindings.
+type ServiceRoleBindingInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1alpha1.ServiceRoleBindingLister
+}
+
+type serviceRoleBindingInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewServiceRoleBindingInformer constructs a new informer for ServiceRoleBinding 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 NewServiceRoleBindingInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredServiceRoleBindingInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredServiceRoleBindingInformer constructs a new informer for ServiceRoleBinding 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 NewFilteredServiceRoleBindingInformer(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.RbacV1alpha1().ServiceRoleBindings(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.RbacV1alpha1().ServiceRoleBindings(namespace).Watch(options)
+			},
+		},
+		&rbacv1alpha1.ServiceRoleBinding{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *serviceRoleBindingInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredServiceRoleBindingInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *serviceRoleBindingInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&rbacv1alpha1.ServiceRoleBinding{}, f.defaultInformer)
+}
+
+func (f *serviceRoleBindingInformer) Lister() v1alpha1.ServiceRoleBindingLister {
+	return v1alpha1.NewServiceRoleBindingLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/security/interface.gen.go

@@ -0,0 +1,30 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package security
+
+import (
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1beta1 "istio.io/client-go/pkg/informers/externalversions/security/v1beta1"
+)
+
+// Interface provides access to each of this group's versions.
+type Interface interface {
+	// V1beta1 provides access to shared informers for resources in V1beta1.
+	V1beta1() v1beta1.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}
+}
+
+// V1beta1 returns a new v1beta1.Interface.
+func (g *group) V1beta1() v1beta1.Interface {
+	return v1beta1.New(g.factory, g.namespace, g.tweakListOptions)
+}

vendor/istio.io/client-go/pkg/informers/externalversions/security/v1beta1/authorizationpolicy.gen.go

@@ -0,0 +1,73 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1beta1
+
+import (
+	time "time"
+
+	securityv1beta1 "istio.io/client-go/pkg/apis/security/v1beta1"
+	versioned "istio.io/client-go/pkg/clientset/versioned"
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+	v1beta1 "istio.io/client-go/pkg/listers/security/v1beta1"
+	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"
+)
+
+// AuthorizationPolicyInformer provides access to a shared informer and lister for
+// AuthorizationPolicies.
+type AuthorizationPolicyInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1beta1.AuthorizationPolicyLister
+}
+
+type authorizationPolicyInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+	namespace        string
+}
+
+// NewAuthorizationPolicyInformer constructs a new informer for AuthorizationPolicy 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 NewAuthorizationPolicyInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredAuthorizationPolicyInformer(client, namespace, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredAuthorizationPolicyInformer constructs a new informer for AuthorizationPolicy 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 NewFilteredAuthorizationPolicyInformer(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.SecurityV1beta1().AuthorizationPolicies(namespace).List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.SecurityV1beta1().AuthorizationPolicies(namespace).Watch(options)
+			},
+		},
+		&securityv1beta1.AuthorizationPolicy{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *authorizationPolicyInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredAuthorizationPolicyInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *authorizationPolicyInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&securityv1beta1.AuthorizationPolicy{}, f.defaultInformer)
+}
+
+func (f *authorizationPolicyInformer) Lister() v1beta1.AuthorizationPolicyLister {
+	return v1beta1.NewAuthorizationPolicyLister(f.Informer().GetIndexer())
+}

vendor/istio.io/client-go/pkg/informers/externalversions/security/v1beta1/interface.gen.go

@@ -0,0 +1,29 @@
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1beta1
+
+import (
+	internalinterfaces "istio.io/client-go/pkg/informers/externalversions/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// AuthorizationPolicies returns a AuthorizationPolicyInformer.
+	AuthorizationPolicies() AuthorizationPolicyInformer
+}
+
+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}
+}
+
+// AuthorizationPolicies returns a AuthorizationPolicyInformer.
+func (v *version) AuthorizationPolicies() AuthorizationPolicyInformer {
+	return &authorizationPolicyInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
+}