controller

type CaCertificateDeletionReconciler interface {
	ReconcileCaCertificateDeletion(req reconcile.Request) error
}

type CaCertificateEventHandler interface {
	CreateCaCertificate(obj *gate_v1.CaCertificate) error
	UpdateCaCertificate(old, new *gate_v1.CaCertificate) error
	DeleteCaCertificate(obj *gate_v1.CaCertificate) error
	GenericCaCertificate(obj *gate_v1.CaCertificate) error
}

type CaCertificateEventHandlerFuncs struct {
	OnCreate  func(obj *gate_v1.CaCertificate) error
	OnUpdate  func(old, new *gate_v1.CaCertificate) error
	OnDelete  func(obj *gate_v1.CaCertificate) error
	OnGeneric func(obj *gate_v1.CaCertificate) error
}

type CaCertificateEventWatcher interface {
	AddEventHandler(ctx context.Context, h CaCertificateEventHandler, predicates ...predicate.Predicate) error
}

type CaCertificateFinalizer interface {
	CaCertificateReconciler

	// name of the finalizer used by this handler.
	// finalizer names should be unique for a single task
	CaCertificateFinalizerName() string

	// finalize the object before it is deleted.
	// Watchers created with a finalizing handler will a
	FinalizeCaCertificate(obj *gate_v1.CaCertificate) error
}

type CaCertificateReconcileLoop interface {
	RunCaCertificateReconciler(ctx context.Context, rec CaCertificateReconciler, predicates ...predicate.Predicate) error
}

type CaCertificateReconciler interface {
	ReconcileCaCertificate(obj *gate_v1.CaCertificate) (reconcile.Result, error)
}

type CaCertificateReconcilerFuncs struct {
	OnReconcileCaCertificate         func(obj *gate_v1.CaCertificate) (reconcile.Result, error)
	OnReconcileCaCertificateDeletion func(req reconcile.Request) error
}

type FilterDeletionReconciler interface {
	ReconcileFilterDeletion(req reconcile.Request) error
}

type FilterEventHandler interface {
	CreateFilter(obj *gate_v1.Filter) error
	UpdateFilter(old, new *gate_v1.Filter) error
	DeleteFilter(obj *gate_v1.Filter) error
	GenericFilter(obj *gate_v1.Filter) error
}

type FilterEventHandlerFuncs struct {
	OnCreate  func(obj *gate_v1.Filter) error
	OnUpdate  func(old, new *gate_v1.Filter) error
	OnDelete  func(obj *gate_v1.Filter) error
	OnGeneric func(obj *gate_v1.Filter) error
}

type FilterEventWatcher interface {
	AddEventHandler(ctx context.Context, h FilterEventHandler, predicates ...predicate.Predicate) error
}

type FilterFinalizer interface {
	FilterReconciler

	// name of the finalizer used by this handler.
	// finalizer names should be unique for a single task
	FilterFinalizerName() string

	// finalize the object before it is deleted.
	// Watchers created with a finalizing handler will a
	FinalizeFilter(obj *gate_v1.Filter) error
}

type FilterReconcileLoop interface {
	RunFilterReconciler(ctx context.Context, rec FilterReconciler, predicates ...predicate.Predicate) error
}

type FilterReconciler interface {
	ReconcileFilter(obj *gate_v1.Filter) (reconcile.Result, error)
}

type FilterReconcilerFuncs struct {
	OnReconcileFilter         func(obj *gate_v1.Filter) (reconcile.Result, error)
	OnReconcileFilterDeletion func(req reconcile.Request) error
}

type GatewayDeletionReconciler interface {
	ReconcileGatewayDeletion(req reconcile.Request) error
}

type GatewayEventHandler interface {
	CreateGateway(obj *gate_v1.Gateway) error
	UpdateGateway(old, new *gate_v1.Gateway) error
	DeleteGateway(obj *gate_v1.Gateway) error
	GenericGateway(obj *gate_v1.Gateway) error
}

type GatewayEventHandlerFuncs struct {
	OnCreate  func(obj *gate_v1.Gateway) error
	OnUpdate  func(old, new *gate_v1.Gateway) error
	OnDelete  func(obj *gate_v1.Gateway) error
	OnGeneric func(obj *gate_v1.Gateway) error
}

type GatewayEventWatcher interface {
	AddEventHandler(ctx context.Context, h GatewayEventHandler, predicates ...predicate.Predicate) error
}

type GatewayFinalizer interface {
	GatewayReconciler

	// name of the finalizer used by this handler.
	// finalizer names should be unique for a single task
	GatewayFinalizerName() string

	// finalize the object before it is deleted.
	// Watchers created with a finalizing handler will a
	FinalizeGateway(obj *gate_v1.Gateway) error
}

type GatewayReconcileLoop interface {
	RunGatewayReconciler(ctx context.Context, rec GatewayReconciler, predicates ...predicate.Predicate) error
}

type GatewayReconciler interface {
	ReconcileGateway(obj *gate_v1.Gateway) (reconcile.Result, error)
}

type GatewayReconcilerFuncs struct {
	OnReconcileGateway         func(obj *gate_v1.Gateway) (reconcile.Result, error)
	OnReconcileGatewayDeletion func(req reconcile.Request) error
}

type MulticlusterCaCertificateDeletionReconciler interface {
	ReconcileCaCertificateDeletion(clusterName string, req reconcile.Request) error
}

type MulticlusterCaCertificateReconcileLoop interface {
	// AddMulticlusterCaCertificateReconciler adds a MulticlusterCaCertificateReconciler to the MulticlusterCaCertificateReconcileLoop.
	AddMulticlusterCaCertificateReconciler(ctx context.Context, rec MulticlusterCaCertificateReconciler, predicates ...predicate.Predicate)
}

type MulticlusterCaCertificateReconciler interface {
	ReconcileCaCertificate(clusterName string, obj *gate_v1.CaCertificate) (reconcile.Result, error)
}

type MulticlusterCaCertificateReconcilerFuncs struct {
	OnReconcileCaCertificate         func(clusterName string, obj *gate_v1.CaCertificate) (reconcile.Result, error)
	OnReconcileCaCertificateDeletion func(clusterName string, req reconcile.Request) error
}

type MulticlusterFilterDeletionReconciler interface {
	ReconcileFilterDeletion(clusterName string, req reconcile.Request) error
}

type MulticlusterFilterReconcileLoop interface {
	// AddMulticlusterFilterReconciler adds a MulticlusterFilterReconciler to the MulticlusterFilterReconcileLoop.
	AddMulticlusterFilterReconciler(ctx context.Context, rec MulticlusterFilterReconciler, predicates ...predicate.Predicate)
}

type MulticlusterFilterReconciler interface {
	ReconcileFilter(clusterName string, obj *gate_v1.Filter) (reconcile.Result, error)
}

type MulticlusterFilterReconcilerFuncs struct {
	OnReconcileFilter         func(clusterName string, obj *gate_v1.Filter) (reconcile.Result, error)
	OnReconcileFilterDeletion func(clusterName string, req reconcile.Request) error
}

type MulticlusterGatewayDeletionReconciler interface {
	ReconcileGatewayDeletion(clusterName string, req reconcile.Request) error
}

type MulticlusterGatewayReconcileLoop interface {
	// AddMulticlusterGatewayReconciler adds a MulticlusterGatewayReconciler to the MulticlusterGatewayReconcileLoop.
	AddMulticlusterGatewayReconciler(ctx context.Context, rec MulticlusterGatewayReconciler, predicates ...predicate.Predicate)
}

type MulticlusterGatewayReconciler interface {
	ReconcileGateway(clusterName string, obj *gate_v1.Gateway) (reconcile.Result, error)
}

type MulticlusterGatewayReconcilerFuncs struct {
	OnReconcileGateway         func(clusterName string, obj *gate_v1.Gateway) (reconcile.Result, error)
	OnReconcileGatewayDeletion func(clusterName string, req reconcile.Request) error
}

type MulticlusterSslCertificateDeletionReconciler interface {
	ReconcileSslCertificateDeletion(clusterName string, req reconcile.Request) error
}

type MulticlusterSslCertificateReconcileLoop interface {
	// AddMulticlusterSslCertificateReconciler adds a MulticlusterSslCertificateReconciler to the MulticlusterSslCertificateReconcileLoop.
	AddMulticlusterSslCertificateReconciler(ctx context.Context, rec MulticlusterSslCertificateReconciler, predicates ...predicate.Predicate)
}

type MulticlusterSslCertificateReconciler interface {
	ReconcileSslCertificate(clusterName string, obj *gate_v1.SslCertificate) (reconcile.Result, error)
}

type MulticlusterSslCertificateReconcilerFuncs struct {
	OnReconcileSslCertificate         func(clusterName string, obj *gate_v1.SslCertificate) (reconcile.Result, error)
	OnReconcileSslCertificateDeletion func(clusterName string, req reconcile.Request) error
}

type MulticlusterUpstreamDeletionReconciler interface {
	ReconcileUpstreamDeletion(clusterName string, req reconcile.Request) error
}

type MulticlusterUpstreamReconcileLoop interface {
	// AddMulticlusterUpstreamReconciler adds a MulticlusterUpstreamReconciler to the MulticlusterUpstreamReconcileLoop.
	AddMulticlusterUpstreamReconciler(ctx context.Context, rec MulticlusterUpstreamReconciler, predicates ...predicate.Predicate)
}

type MulticlusterUpstreamReconciler interface {
	ReconcileUpstream(clusterName string, obj *gate_v1.Upstream) (reconcile.Result, error)
}

type MulticlusterUpstreamReconcilerFuncs struct {
	OnReconcileUpstream         func(clusterName string, obj *gate_v1.Upstream) (reconcile.Result, error)
	OnReconcileUpstreamDeletion func(clusterName string, req reconcile.Request) error
}

type SslCertificateDeletionReconciler interface {
	ReconcileSslCertificateDeletion(req reconcile.Request) error
}

type SslCertificateEventHandler interface {
	CreateSslCertificate(obj *gate_v1.SslCertificate) error
	UpdateSslCertificate(old, new *gate_v1.SslCertificate) error
	DeleteSslCertificate(obj *gate_v1.SslCertificate) error
	GenericSslCertificate(obj *gate_v1.SslCertificate) error
}

type SslCertificateEventHandlerFuncs struct {
	OnCreate  func(obj *gate_v1.SslCertificate) error
	OnUpdate  func(old, new *gate_v1.SslCertificate) error
	OnDelete  func(obj *gate_v1.SslCertificate) error
	OnGeneric func(obj *gate_v1.SslCertificate) error
}

type SslCertificateEventWatcher interface {
	AddEventHandler(ctx context.Context, h SslCertificateEventHandler, predicates ...predicate.Predicate) error
}

type SslCertificateFinalizer interface {
	SslCertificateReconciler

	// name of the finalizer used by this handler.
	// finalizer names should be unique for a single task
	SslCertificateFinalizerName() string

	// finalize the object before it is deleted.
	// Watchers created with a finalizing handler will a
	FinalizeSslCertificate(obj *gate_v1.SslCertificate) error
}

type SslCertificateReconcileLoop interface {
	RunSslCertificateReconciler(ctx context.Context, rec SslCertificateReconciler, predicates ...predicate.Predicate) error
}

type SslCertificateReconciler interface {
	ReconcileSslCertificate(obj *gate_v1.SslCertificate) (reconcile.Result, error)
}

type SslCertificateReconcilerFuncs struct {
	OnReconcileSslCertificate         func(obj *gate_v1.SslCertificate) (reconcile.Result, error)
	OnReconcileSslCertificateDeletion func(req reconcile.Request) error
}

type UpstreamDeletionReconciler interface {
	ReconcileUpstreamDeletion(req reconcile.Request) error
}

type UpstreamEventHandler interface {
	CreateUpstream(obj *gate_v1.Upstream) error
	UpdateUpstream(old, new *gate_v1.Upstream) error
	DeleteUpstream(obj *gate_v1.Upstream) error
	GenericUpstream(obj *gate_v1.Upstream) error
}

type UpstreamEventHandlerFuncs struct {
	OnCreate  func(obj *gate_v1.Upstream) error
	OnUpdate  func(old, new *gate_v1.Upstream) error
	OnDelete  func(obj *gate_v1.Upstream) error
	OnGeneric func(obj *gate_v1.Upstream) error
}

type UpstreamEventWatcher interface {
	AddEventHandler(ctx context.Context, h UpstreamEventHandler, predicates ...predicate.Predicate) error
}

type UpstreamFinalizer interface {
	UpstreamReconciler

	// name of the finalizer used by this handler.
	// finalizer names should be unique for a single task
	UpstreamFinalizerName() string

	// finalize the object before it is deleted.
	// Watchers created with a finalizing handler will a
	FinalizeUpstream(obj *gate_v1.Upstream) error
}

type UpstreamReconcileLoop interface {
	RunUpstreamReconciler(ctx context.Context, rec UpstreamReconciler, predicates ...predicate.Predicate) error
}

type UpstreamReconciler interface {
	ReconcileUpstream(obj *gate_v1.Upstream) (reconcile.Result, error)
}

type UpstreamReconcilerFuncs struct {
	OnReconcileUpstream         func(obj *gate_v1.Upstream) (reconcile.Result, error)
	OnReconcileUpstreamDeletion func(req reconcile.Request) error
}