v1

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 27, 2022 License: Apache-2.0 Imports: 19 Imported by: 0

Documentation

Overview

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package v1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Index

Constants

This section is empty.

Variables

View Source 
var CACertificateService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.CACertificateService",
	HandlerType: (*CACertificateServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetCACertificate",
			Handler:    _CACertificateService_GetCACertificate_Handler,
		},
		{
			MethodName: "CreateCACertificate",
			Handler:    _CACertificateService_CreateCACertificate_Handler,
		},
		{
			MethodName: "UpsertCACertificate",
			Handler:    _CACertificateService_UpsertCACertificate_Handler,
		},
		{
			MethodName: "DeleteCACertificate",
			Handler:    _CACertificateService_DeleteCACertificate_Handler,
		},
		{
			MethodName: "ListCACertificates",
			Handler:    _CACertificateService_ListCACertificates_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/ca_certificate.proto",
}

CACertificateService_ServiceDesc is the grpc.ServiceDesc for CACertificateService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var CertificateService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.CertificateService",
	HandlerType: (*CertificateServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetCertificate",
			Handler:    _CertificateService_GetCertificate_Handler,
		},
		{
			MethodName: "CreateCertificate",
			Handler:    _CertificateService_CreateCertificate_Handler,
		},
		{
			MethodName: "UpsertCertificate",
			Handler:    _CertificateService_UpsertCertificate_Handler,
		},
		{
			MethodName: "DeleteCertificate",
			Handler:    _CertificateService_DeleteCertificate_Handler,
		},
		{
			MethodName: "ListCertificates",
			Handler:    _CertificateService_ListCertificates_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/certificate.proto",
}

CertificateService_ServiceDesc is the grpc.ServiceDesc for CertificateService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ConsumerService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.ConsumerService",
	HandlerType: (*ConsumerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetConsumer",
			Handler:    _ConsumerService_GetConsumer_Handler,
		},
		{
			MethodName: "CreateConsumer",
			Handler:    _ConsumerService_CreateConsumer_Handler,
		},
		{
			MethodName: "UpsertConsumer",
			Handler:    _ConsumerService_UpsertConsumer_Handler,
		},
		{
			MethodName: "DeleteConsumer",
			Handler:    _ConsumerService_DeleteConsumer_Handler,
		},
		{
			MethodName: "ListConsumers",
			Handler:    _ConsumerService_ListConsumers_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/consumer.proto",
}

ConsumerService_ServiceDesc is the grpc.ServiceDesc for ConsumerService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var File_kong_admin_service_v1_admin_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_ca_certificate_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_certificate_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_consumer_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_node_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_plugin_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_plugin_schema_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_route_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_schemas_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_service_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_sni_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_status_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_target_proto protoreflect.FileDescriptor
View Source 
var File_kong_admin_service_v1_upstream_proto protoreflect.FileDescriptor
View Source 
var MetaService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.MetaService",
	HandlerType: (*MetaServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetVersion",
			Handler:    _MetaService_GetVersion_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/admin.proto",
}

MetaService_ServiceDesc is the grpc.ServiceDesc for MetaService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var NodeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.NodeService",
	HandlerType: (*NodeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetNode",
			Handler:    _NodeService_GetNode_Handler,
		},
		{
			MethodName: "CreateNode",
			Handler:    _NodeService_CreateNode_Handler,
		},
		{
			MethodName: "UpsertNode",
			Handler:    _NodeService_UpsertNode_Handler,
		},
		{
			MethodName: "DeleteNode",
			Handler:    _NodeService_DeleteNode_Handler,
		},
		{
			MethodName: "ListNodes",
			Handler:    _NodeService_ListNodes_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/node.proto",
}

NodeService_ServiceDesc is the grpc.ServiceDesc for NodeService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var PluginSchemaService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.PluginSchemaService",
	HandlerType: (*PluginSchemaServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateLuaPluginSchema",
			Handler:    _PluginSchemaService_CreateLuaPluginSchema_Handler,
		},
		{
			MethodName: "GetLuaPluginSchema",
			Handler:    _PluginSchemaService_GetLuaPluginSchema_Handler,
		},
		{
			MethodName: "ListLuaPluginSchemas",
			Handler:    _PluginSchemaService_ListLuaPluginSchemas_Handler,
		},
		{
			MethodName: "UpsertLuaPluginSchema",
			Handler:    _PluginSchemaService_UpsertLuaPluginSchema_Handler,
		},
		{
			MethodName: "DeleteLuaPluginSchema",
			Handler:    _PluginSchemaService_DeleteLuaPluginSchema_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/plugin_schema.proto",
}

PluginSchemaService_ServiceDesc is the grpc.ServiceDesc for PluginSchemaService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var PluginService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.PluginService",
	HandlerType: (*PluginServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetConfiguredPlugins",
			Handler:    _PluginService_GetConfiguredPlugins_Handler,
		},
		{
			MethodName: "GetAvailablePlugins",
			Handler:    _PluginService_GetAvailablePlugins_Handler,
		},
		{
			MethodName: "GetPlugin",
			Handler:    _PluginService_GetPlugin_Handler,
		},
		{
			MethodName: "CreatePlugin",
			Handler:    _PluginService_CreatePlugin_Handler,
		},
		{
			MethodName: "UpsertPlugin",
			Handler:    _PluginService_UpsertPlugin_Handler,
		},
		{
			MethodName: "DeletePlugin",
			Handler:    _PluginService_DeletePlugin_Handler,
		},
		{
			MethodName: "ListPlugins",
			Handler:    _PluginService_ListPlugins_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/plugin.proto",
}

PluginService_ServiceDesc is the grpc.ServiceDesc for PluginService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var RouteService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.RouteService",
	HandlerType: (*RouteServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetRoute",
			Handler:    _RouteService_GetRoute_Handler,
		},
		{
			MethodName: "CreateRoute",
			Handler:    _RouteService_CreateRoute_Handler,
		},
		{
			MethodName: "UpsertRoute",
			Handler:    _RouteService_UpsertRoute_Handler,
		},
		{
			MethodName: "DeleteRoute",
			Handler:    _RouteService_DeleteRoute_Handler,
		},
		{
			MethodName: "ListRoutes",
			Handler:    _RouteService_ListRoutes_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/route.proto",
}

RouteService_ServiceDesc is the grpc.ServiceDesc for RouteService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var SNIService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.SNIService",
	HandlerType: (*SNIServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetSNI",
			Handler:    _SNIService_GetSNI_Handler,
		},
		{
			MethodName: "CreateSNI",
			Handler:    _SNIService_CreateSNI_Handler,
		},
		{
			MethodName: "UpsertSNI",
			Handler:    _SNIService_UpsertSNI_Handler,
		},
		{
			MethodName: "DeleteSNI",
			Handler:    _SNIService_DeleteSNI_Handler,
		},
		{
			MethodName: "ListSNIs",
			Handler:    _SNIService_ListSNIs_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/sni.proto",
}

SNIService_ServiceDesc is the grpc.ServiceDesc for SNIService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var SchemasService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.SchemasService",
	HandlerType: (*SchemasServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ValidateLuaPlugin",
			Handler:    _SchemasService_ValidateLuaPlugin_Handler,
		},
		{
			MethodName: "ValidateCACertificateSchema",
			Handler:    _SchemasService_ValidateCACertificateSchema_Handler,
		},
		{
			MethodName: "ValidateCertificateSchema",
			Handler:    _SchemasService_ValidateCertificateSchema_Handler,
		},
		{
			MethodName: "ValidateConsumerSchema",
			Handler:    _SchemasService_ValidateConsumerSchema_Handler,
		},
		{
			MethodName: "ValidatePluginSchema",
			Handler:    _SchemasService_ValidatePluginSchema_Handler,
		},
		{
			MethodName: "ValidateRouteSchema",
			Handler:    _SchemasService_ValidateRouteSchema_Handler,
		},
		{
			MethodName: "ValidateServiceSchema",
			Handler:    _SchemasService_ValidateServiceSchema_Handler,
		},
		{
			MethodName: "ValidateSNISchema",
			Handler:    _SchemasService_ValidateSNISchema_Handler,
		},
		{
			MethodName: "ValidateTargetSchema",
			Handler:    _SchemasService_ValidateTargetSchema_Handler,
		},
		{
			MethodName: "ValidateUpstreamSchema",
			Handler:    _SchemasService_ValidateUpstreamSchema_Handler,
		},
		{
			MethodName: "GetSchemas",
			Handler:    _SchemasService_GetSchemas_Handler,
		},
		{
			MethodName: "GetLuaSchemasPlugin",
			Handler:    _SchemasService_GetLuaSchemasPlugin_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/schemas.proto",
}

SchemasService_ServiceDesc is the grpc.ServiceDesc for SchemasService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ServiceService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.ServiceService",
	HandlerType: (*ServiceServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetService",
			Handler:    _ServiceService_GetService_Handler,
		},
		{
			MethodName: "CreateService",
			Handler:    _ServiceService_CreateService_Handler,
		},
		{
			MethodName: "UpsertService",
			Handler:    _ServiceService_UpsertService_Handler,
		},
		{
			MethodName: "DeleteService",
			Handler:    _ServiceService_DeleteService_Handler,
		},
		{
			MethodName: "ListServices",
			Handler:    _ServiceService_ListServices_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/service.proto",
}

ServiceService_ServiceDesc is the grpc.ServiceDesc for ServiceService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var StatusService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.StatusService",
	HandlerType: (*StatusServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetHash",
			Handler:    _StatusService_GetHash_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/status.proto",
}

StatusService_ServiceDesc is the grpc.ServiceDesc for StatusService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var TargetService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.TargetService",
	HandlerType: (*TargetServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetTarget",
			Handler:    _TargetService_GetTarget_Handler,
		},
		{
			MethodName: "CreateTarget",
			Handler:    _TargetService_CreateTarget_Handler,
		},
		{
			MethodName: "UpsertTarget",
			Handler:    _TargetService_UpsertTarget_Handler,
		},
		{
			MethodName: "DeleteTarget",
			Handler:    _TargetService_DeleteTarget_Handler,
		},
		{
			MethodName: "ListTargets",
			Handler:    _TargetService_ListTargets_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/target.proto",
}

TargetService_ServiceDesc is the grpc.ServiceDesc for TargetService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var UpstreamService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "kong.admin.service.v1.UpstreamService",
	HandlerType: (*UpstreamServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetUpstream",
			Handler:    _UpstreamService_GetUpstream_Handler,
		},
		{
			MethodName: "CreateUpstream",
			Handler:    _UpstreamService_CreateUpstream_Handler,
		},
		{
			MethodName: "UpsertUpstream",
			Handler:    _UpstreamService_UpsertUpstream_Handler,
		},
		{
			MethodName: "DeleteUpstream",
			Handler:    _UpstreamService_DeleteUpstream_Handler,
		},
		{
			MethodName: "ListUpstreams",
			Handler:    _UpstreamService_ListUpstreams_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "kong/admin/service/v1/upstream.proto",
}

UpstreamService_ServiceDesc is the grpc.ServiceDesc for UpstreamService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

Functions

func RegisterCACertificateServiceHandler 

func RegisterCACertificateServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCACertificateServiceHandler registers the http handlers for service CACertificateService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCACertificateServiceHandlerClient 

func RegisterCACertificateServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client CACertificateServiceClient) error

RegisterCACertificateServiceHandlerClient registers the http handlers for service CACertificateService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "CACertificateServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "CACertificateServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "CACertificateServiceClient" to call the correct interceptors.

func RegisterCACertificateServiceHandlerFromEndpoint 

func RegisterCACertificateServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCACertificateServiceHandlerFromEndpoint is same as RegisterCACertificateServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCACertificateServiceHandlerServer 

func RegisterCACertificateServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server CACertificateServiceServer) error

RegisterCACertificateServiceHandlerServer registers the http handlers for service CACertificateService to "mux". UnaryRPC :call CACertificateServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCACertificateServiceHandlerFromEndpoint instead.

func RegisterCACertificateServiceServer 

func RegisterCACertificateServiceServer(s grpc.ServiceRegistrar, srv CACertificateServiceServer)

func RegisterCertificateServiceHandler 

func RegisterCertificateServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterCertificateServiceHandler registers the http handlers for service CertificateService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterCertificateServiceHandlerClient 

func RegisterCertificateServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client CertificateServiceClient) error

RegisterCertificateServiceHandlerClient registers the http handlers for service CertificateService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "CertificateServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "CertificateServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "CertificateServiceClient" to call the correct interceptors.

func RegisterCertificateServiceHandlerFromEndpoint 

func RegisterCertificateServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterCertificateServiceHandlerFromEndpoint is same as RegisterCertificateServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterCertificateServiceHandlerServer 

func RegisterCertificateServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server CertificateServiceServer) error

RegisterCertificateServiceHandlerServer registers the http handlers for service CertificateService to "mux". UnaryRPC :call CertificateServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterCertificateServiceHandlerFromEndpoint instead.

func RegisterCertificateServiceServer 

func RegisterCertificateServiceServer(s grpc.ServiceRegistrar, srv CertificateServiceServer)

func RegisterConsumerServiceHandler 

func RegisterConsumerServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterConsumerServiceHandler registers the http handlers for service ConsumerService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterConsumerServiceHandlerClient 

func RegisterConsumerServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ConsumerServiceClient) error

RegisterConsumerServiceHandlerClient registers the http handlers for service ConsumerService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ConsumerServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ConsumerServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ConsumerServiceClient" to call the correct interceptors.

func RegisterConsumerServiceHandlerFromEndpoint 

func RegisterConsumerServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterConsumerServiceHandlerFromEndpoint is same as RegisterConsumerServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterConsumerServiceHandlerServer 

func RegisterConsumerServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ConsumerServiceServer) error

RegisterConsumerServiceHandlerServer registers the http handlers for service ConsumerService to "mux". UnaryRPC :call ConsumerServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterConsumerServiceHandlerFromEndpoint instead.

func RegisterConsumerServiceServer 

func RegisterConsumerServiceServer(s grpc.ServiceRegistrar, srv ConsumerServiceServer)

func RegisterMetaServiceHandler 

func RegisterMetaServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterMetaServiceHandler registers the http handlers for service MetaService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterMetaServiceHandlerClient 

func RegisterMetaServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MetaServiceClient) error

RegisterMetaServiceHandlerClient registers the http handlers for service MetaService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "MetaServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MetaServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "MetaServiceClient" to call the correct interceptors.

func RegisterMetaServiceHandlerFromEndpoint 

func RegisterMetaServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterMetaServiceHandlerFromEndpoint is same as RegisterMetaServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterMetaServiceHandlerServer 

func RegisterMetaServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MetaServiceServer) error

RegisterMetaServiceHandlerServer registers the http handlers for service MetaService to "mux". UnaryRPC :call MetaServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterMetaServiceHandlerFromEndpoint instead.

func RegisterMetaServiceServer 

func RegisterMetaServiceServer(s grpc.ServiceRegistrar, srv MetaServiceServer)

func RegisterNodeServiceHandler 

func RegisterNodeServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNodeServiceHandler registers the http handlers for service NodeService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNodeServiceHandlerClient 

func RegisterNodeServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NodeServiceClient) error

RegisterNodeServiceHandlerClient registers the http handlers for service NodeService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NodeServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NodeServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "NodeServiceClient" to call the correct interceptors.

func RegisterNodeServiceHandlerFromEndpoint 

func RegisterNodeServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNodeServiceHandlerFromEndpoint is same as RegisterNodeServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNodeServiceHandlerServer 

func RegisterNodeServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server NodeServiceServer) error

RegisterNodeServiceHandlerServer registers the http handlers for service NodeService to "mux". UnaryRPC :call NodeServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterNodeServiceHandlerFromEndpoint instead.

func RegisterNodeServiceServer 

func RegisterNodeServiceServer(s grpc.ServiceRegistrar, srv NodeServiceServer)

func RegisterPluginSchemaServiceHandler 

func RegisterPluginSchemaServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterPluginSchemaServiceHandler registers the http handlers for service PluginSchemaService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterPluginSchemaServiceHandlerClient 

func RegisterPluginSchemaServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client PluginSchemaServiceClient) error

RegisterPluginSchemaServiceHandlerClient registers the http handlers for service PluginSchemaService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "PluginSchemaServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "PluginSchemaServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "PluginSchemaServiceClient" to call the correct interceptors.

func RegisterPluginSchemaServiceHandlerFromEndpoint 

func RegisterPluginSchemaServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterPluginSchemaServiceHandlerFromEndpoint is same as RegisterPluginSchemaServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterPluginSchemaServiceHandlerServer 

func RegisterPluginSchemaServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server PluginSchemaServiceServer) error

RegisterPluginSchemaServiceHandlerServer registers the http handlers for service PluginSchemaService to "mux". UnaryRPC :call PluginSchemaServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterPluginSchemaServiceHandlerFromEndpoint instead.

func RegisterPluginSchemaServiceServer 

func RegisterPluginSchemaServiceServer(s grpc.ServiceRegistrar, srv PluginSchemaServiceServer)

func RegisterPluginServiceHandler 

func RegisterPluginServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterPluginServiceHandler registers the http handlers for service PluginService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterPluginServiceHandlerClient 

func RegisterPluginServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client PluginServiceClient) error

RegisterPluginServiceHandlerClient registers the http handlers for service PluginService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "PluginServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "PluginServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "PluginServiceClient" to call the correct interceptors.

func RegisterPluginServiceHandlerFromEndpoint 

func RegisterPluginServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterPluginServiceHandlerFromEndpoint is same as RegisterPluginServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterPluginServiceHandlerServer 

func RegisterPluginServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server PluginServiceServer) error

RegisterPluginServiceHandlerServer registers the http handlers for service PluginService to "mux". UnaryRPC :call PluginServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterPluginServiceHandlerFromEndpoint instead.

func RegisterPluginServiceServer 

func RegisterPluginServiceServer(s grpc.ServiceRegistrar, srv PluginServiceServer)

func RegisterRouteServiceHandler 

func RegisterRouteServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterRouteServiceHandler registers the http handlers for service RouteService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterRouteServiceHandlerClient 

func RegisterRouteServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client RouteServiceClient) error

RegisterRouteServiceHandlerClient registers the http handlers for service RouteService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "RouteServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "RouteServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "RouteServiceClient" to call the correct interceptors.

func RegisterRouteServiceHandlerFromEndpoint 

func RegisterRouteServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterRouteServiceHandlerFromEndpoint is same as RegisterRouteServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterRouteServiceHandlerServer 

func RegisterRouteServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server RouteServiceServer) error

RegisterRouteServiceHandlerServer registers the http handlers for service RouteService to "mux". UnaryRPC :call RouteServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterRouteServiceHandlerFromEndpoint instead.

func RegisterRouteServiceServer 

func RegisterRouteServiceServer(s grpc.ServiceRegistrar, srv RouteServiceServer)

func RegisterSNIServiceHandler 

func RegisterSNIServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterSNIServiceHandler registers the http handlers for service SNIService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterSNIServiceHandlerClient 

func RegisterSNIServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SNIServiceClient) error

RegisterSNIServiceHandlerClient registers the http handlers for service SNIService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "SNIServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SNIServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "SNIServiceClient" to call the correct interceptors.

func RegisterSNIServiceHandlerFromEndpoint 

func RegisterSNIServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterSNIServiceHandlerFromEndpoint is same as RegisterSNIServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterSNIServiceHandlerServer 

func RegisterSNIServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SNIServiceServer) error

RegisterSNIServiceHandlerServer registers the http handlers for service SNIService to "mux". UnaryRPC :call SNIServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterSNIServiceHandlerFromEndpoint instead.

func RegisterSNIServiceServer 

func RegisterSNIServiceServer(s grpc.ServiceRegistrar, srv SNIServiceServer)

func RegisterSchemasServiceHandler 

func RegisterSchemasServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterSchemasServiceHandler registers the http handlers for service SchemasService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterSchemasServiceHandlerClient 

func RegisterSchemasServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SchemasServiceClient) error

RegisterSchemasServiceHandlerClient registers the http handlers for service SchemasService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "SchemasServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SchemasServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "SchemasServiceClient" to call the correct interceptors.

func RegisterSchemasServiceHandlerFromEndpoint 

func RegisterSchemasServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterSchemasServiceHandlerFromEndpoint is same as RegisterSchemasServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterSchemasServiceHandlerServer 

func RegisterSchemasServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SchemasServiceServer) error

RegisterSchemasServiceHandlerServer registers the http handlers for service SchemasService to "mux". UnaryRPC :call SchemasServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterSchemasServiceHandlerFromEndpoint instead.

func RegisterSchemasServiceServer 

func RegisterSchemasServiceServer(s grpc.ServiceRegistrar, srv SchemasServiceServer)

func RegisterServiceServiceHandler 

func RegisterServiceServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterServiceServiceHandler registers the http handlers for service ServiceService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterServiceServiceHandlerClient 

func RegisterServiceServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ServiceServiceClient) error

RegisterServiceServiceHandlerClient registers the http handlers for service ServiceService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ServiceServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ServiceServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ServiceServiceClient" to call the correct interceptors.

func RegisterServiceServiceHandlerFromEndpoint 

func RegisterServiceServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterServiceServiceHandlerFromEndpoint is same as RegisterServiceServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterServiceServiceHandlerServer 

func RegisterServiceServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ServiceServiceServer) error

RegisterServiceServiceHandlerServer registers the http handlers for service ServiceService to "mux". UnaryRPC :call ServiceServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterServiceServiceHandlerFromEndpoint instead.

func RegisterServiceServiceServer 

func RegisterServiceServiceServer(s grpc.ServiceRegistrar, srv ServiceServiceServer)

func RegisterStatusServiceHandler 

func RegisterStatusServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterStatusServiceHandler registers the http handlers for service StatusService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterStatusServiceHandlerClient 

func RegisterStatusServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client StatusServiceClient) error

RegisterStatusServiceHandlerClient registers the http handlers for service StatusService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "StatusServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "StatusServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "StatusServiceClient" to call the correct interceptors.

func RegisterStatusServiceHandlerFromEndpoint 

func RegisterStatusServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterStatusServiceHandlerFromEndpoint is same as RegisterStatusServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterStatusServiceHandlerServer 

func RegisterStatusServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server StatusServiceServer) error

RegisterStatusServiceHandlerServer registers the http handlers for service StatusService to "mux". UnaryRPC :call StatusServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterStatusServiceHandlerFromEndpoint instead.

func RegisterStatusServiceServer 

func RegisterStatusServiceServer(s grpc.ServiceRegistrar, srv StatusServiceServer)

func RegisterTargetServiceHandler 

func RegisterTargetServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterTargetServiceHandler registers the http handlers for service TargetService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterTargetServiceHandlerClient 

func RegisterTargetServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client TargetServiceClient) error

RegisterTargetServiceHandlerClient registers the http handlers for service TargetService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "TargetServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "TargetServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "TargetServiceClient" to call the correct interceptors.

func RegisterTargetServiceHandlerFromEndpoint 

func RegisterTargetServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterTargetServiceHandlerFromEndpoint is same as RegisterTargetServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterTargetServiceHandlerServer 

func RegisterTargetServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server TargetServiceServer) error

RegisterTargetServiceHandlerServer registers the http handlers for service TargetService to "mux". UnaryRPC :call TargetServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterTargetServiceHandlerFromEndpoint instead.

func RegisterTargetServiceServer 

func RegisterTargetServiceServer(s grpc.ServiceRegistrar, srv TargetServiceServer)

func RegisterUpstreamServiceHandler 

func RegisterUpstreamServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterUpstreamServiceHandler registers the http handlers for service UpstreamService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterUpstreamServiceHandlerClient 

func RegisterUpstreamServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client UpstreamServiceClient) error

RegisterUpstreamServiceHandlerClient registers the http handlers for service UpstreamService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "UpstreamServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "UpstreamServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "UpstreamServiceClient" to call the correct interceptors.

func RegisterUpstreamServiceHandlerFromEndpoint 

func RegisterUpstreamServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterUpstreamServiceHandlerFromEndpoint is same as RegisterUpstreamServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterUpstreamServiceHandlerServer 

func RegisterUpstreamServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server UpstreamServiceServer) error

RegisterUpstreamServiceHandlerServer registers the http handlers for service UpstreamService to "mux". UnaryRPC :call UpstreamServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterUpstreamServiceHandlerFromEndpoint instead.

func RegisterUpstreamServiceServer 

func RegisterUpstreamServiceServer(s grpc.ServiceRegistrar, srv UpstreamServiceServer)

Types

type CACertificateServiceClient 

type CACertificateServiceClient interface {
	GetCACertificate(ctx context.Context, in *GetCACertificateRequest, opts ...grpc.CallOption) (*GetCACertificateResponse, error)
	CreateCACertificate(ctx context.Context, in *CreateCACertificateRequest, opts ...grpc.CallOption) (*CreateCACertificateResponse, error)
	UpsertCACertificate(ctx context.Context, in *UpsertCACertificateRequest, opts ...grpc.CallOption) (*UpsertCACertificateResponse, error)
	DeleteCACertificate(ctx context.Context, in *DeleteCACertificateRequest, opts ...grpc.CallOption) (*DeleteCACertificateResponse, error)
	ListCACertificates(ctx context.Context, in *ListCACertificatesRequest, opts ...grpc.CallOption) (*ListCACertificatesResponse, error)
}

CACertificateServiceClient is the client API for CACertificateService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewCACertificateServiceClient 

func NewCACertificateServiceClient(cc grpc.ClientConnInterface) CACertificateServiceClient

type CACertificateServiceServer 

type CACertificateServiceServer interface {
	GetCACertificate(context.Context, *GetCACertificateRequest) (*GetCACertificateResponse, error)
	CreateCACertificate(context.Context, *CreateCACertificateRequest) (*CreateCACertificateResponse, error)
	UpsertCACertificate(context.Context, *UpsertCACertificateRequest) (*UpsertCACertificateResponse, error)
	DeleteCACertificate(context.Context, *DeleteCACertificateRequest) (*DeleteCACertificateResponse, error)
	ListCACertificates(context.Context, *ListCACertificatesRequest) (*ListCACertificatesResponse, error)
	// contains filtered or unexported methods
}

CACertificateServiceServer is the server API for CACertificateService service. All implementations must embed UnimplementedCACertificateServiceServer for forward compatibility

type CertificateServiceClient 

type CertificateServiceClient interface {
	GetCertificate(ctx context.Context, in *GetCertificateRequest, opts ...grpc.CallOption) (*GetCertificateResponse, error)
	CreateCertificate(ctx context.Context, in *CreateCertificateRequest, opts ...grpc.CallOption) (*CreateCertificateResponse, error)
	UpsertCertificate(ctx context.Context, in *UpsertCertificateRequest, opts ...grpc.CallOption) (*UpsertCertificateResponse, error)
	DeleteCertificate(ctx context.Context, in *DeleteCertificateRequest, opts ...grpc.CallOption) (*DeleteCertificateResponse, error)
	ListCertificates(ctx context.Context, in *ListCertificatesRequest, opts ...grpc.CallOption) (*ListCertificatesResponse, error)
}

CertificateServiceClient is the client API for CertificateService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewCertificateServiceClient 

func NewCertificateServiceClient(cc grpc.ClientConnInterface) CertificateServiceClient

type CertificateServiceServer 

type CertificateServiceServer interface {
	GetCertificate(context.Context, *GetCertificateRequest) (*GetCertificateResponse, error)
	CreateCertificate(context.Context, *CreateCertificateRequest) (*CreateCertificateResponse, error)
	UpsertCertificate(context.Context, *UpsertCertificateRequest) (*UpsertCertificateResponse, error)
	DeleteCertificate(context.Context, *DeleteCertificateRequest) (*DeleteCertificateResponse, error)
	ListCertificates(context.Context, *ListCertificatesRequest) (*ListCertificatesResponse, error)
	// contains filtered or unexported methods
}

CertificateServiceServer is the server API for CertificateService service. All implementations must embed UnimplementedCertificateServiceServer for forward compatibility

type ConsumerServiceClient 

type ConsumerServiceClient interface {
	GetConsumer(ctx context.Context, in *GetConsumerRequest, opts ...grpc.CallOption) (*GetConsumerResponse, error)
	CreateConsumer(ctx context.Context, in *CreateConsumerRequest, opts ...grpc.CallOption) (*CreateConsumerResponse, error)
	UpsertConsumer(ctx context.Context, in *UpsertConsumerRequest, opts ...grpc.CallOption) (*UpsertConsumerResponse, error)
	DeleteConsumer(ctx context.Context, in *DeleteConsumerRequest, opts ...grpc.CallOption) (*DeleteConsumerResponse, error)
	ListConsumers(ctx context.Context, in *ListConsumersRequest, opts ...grpc.CallOption) (*ListConsumersResponse, error)
}

ConsumerServiceClient is the client API for ConsumerService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewConsumerServiceClient 

func NewConsumerServiceClient(cc grpc.ClientConnInterface) ConsumerServiceClient

type ConsumerServiceServer 

type ConsumerServiceServer interface {
	GetConsumer(context.Context, *GetConsumerRequest) (*GetConsumerResponse, error)
	CreateConsumer(context.Context, *CreateConsumerRequest) (*CreateConsumerResponse, error)
	UpsertConsumer(context.Context, *UpsertConsumerRequest) (*UpsertConsumerResponse, error)
	DeleteConsumer(context.Context, *DeleteConsumerRequest) (*DeleteConsumerResponse, error)
	ListConsumers(context.Context, *ListConsumersRequest) (*ListConsumersResponse, error)
	// contains filtered or unexported methods
}

ConsumerServiceServer is the server API for ConsumerService service. All implementations must embed UnimplementedConsumerServiceServer for forward compatibility

type CreateCACertificateRequest 

type CreateCACertificateRequest struct {
	Item    *v1.CACertificate  `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateCACertificateRequest) Descriptor deprecated 

func (*CreateCACertificateRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateCACertificateRequest.ProtoReflect.Descriptor instead.

func (*CreateCACertificateRequest) GetCluster 

func (x *CreateCACertificateRequest) GetCluster() *v1.RequestCluster

func (*CreateCACertificateRequest) GetItem 

func (x *CreateCACertificateRequest) GetItem() *v1.CACertificate

func (*CreateCACertificateRequest) ProtoMessage 

func (*CreateCACertificateRequest) ProtoMessage()

func (*CreateCACertificateRequest) ProtoReflect 

func (x *CreateCACertificateRequest) ProtoReflect() protoreflect.Message

func (*CreateCACertificateRequest) Reset 

func (x *CreateCACertificateRequest) Reset()

func (*CreateCACertificateRequest) String 

func (x *CreateCACertificateRequest) String() string

type CreateCACertificateResponse 

type CreateCACertificateResponse struct {
	Item *v1.CACertificate `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateCACertificateResponse) Descriptor deprecated 

func (*CreateCACertificateResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateCACertificateResponse.ProtoReflect.Descriptor instead.

func (*CreateCACertificateResponse) GetItem 

func (x *CreateCACertificateResponse) GetItem() *v1.CACertificate

func (*CreateCACertificateResponse) ProtoMessage 

func (*CreateCACertificateResponse) ProtoMessage()

func (*CreateCACertificateResponse) ProtoReflect 

func (x *CreateCACertificateResponse) ProtoReflect() protoreflect.Message

func (*CreateCACertificateResponse) Reset 

func (x *CreateCACertificateResponse) Reset()

func (*CreateCACertificateResponse) String 

func (x *CreateCACertificateResponse) String() string

type CreateCertificateRequest 

type CreateCertificateRequest struct {
	Item    *v1.Certificate    `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateCertificateRequest) Descriptor deprecated 

func (*CreateCertificateRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateCertificateRequest.ProtoReflect.Descriptor instead.

func (*CreateCertificateRequest) GetCluster 

func (x *CreateCertificateRequest) GetCluster() *v1.RequestCluster

func (*CreateCertificateRequest) GetItem 

func (x *CreateCertificateRequest) GetItem() *v1.Certificate

func (*CreateCertificateRequest) ProtoMessage 

func (*CreateCertificateRequest) ProtoMessage()

func (*CreateCertificateRequest) ProtoReflect 

func (x *CreateCertificateRequest) ProtoReflect() protoreflect.Message

func (*CreateCertificateRequest) Reset 

func (x *CreateCertificateRequest) Reset()

func (*CreateCertificateRequest) String 

func (x *CreateCertificateRequest) String() string

type CreateCertificateResponse 

type CreateCertificateResponse struct {
	Item *v1.Certificate `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateCertificateResponse) Descriptor deprecated 

func (*CreateCertificateResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateCertificateResponse.ProtoReflect.Descriptor instead.

func (*CreateCertificateResponse) GetItem 

func (x *CreateCertificateResponse) GetItem() *v1.Certificate

func (*CreateCertificateResponse) ProtoMessage 

func (*CreateCertificateResponse) ProtoMessage()

func (*CreateCertificateResponse) ProtoReflect 

func (x *CreateCertificateResponse) ProtoReflect() protoreflect.Message

func (*CreateCertificateResponse) Reset 

func (x *CreateCertificateResponse) Reset()

func (*CreateCertificateResponse) String 

func (x *CreateCertificateResponse) String() string

type CreateConsumerRequest 

type CreateConsumerRequest struct {
	Item    *v1.Consumer       `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateConsumerRequest) Descriptor deprecated 

func (*CreateConsumerRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateConsumerRequest.ProtoReflect.Descriptor instead.

func (*CreateConsumerRequest) GetCluster 

func (x *CreateConsumerRequest) GetCluster() *v1.RequestCluster

func (*CreateConsumerRequest) GetItem 

func (x *CreateConsumerRequest) GetItem() *v1.Consumer

func (*CreateConsumerRequest) ProtoMessage 

func (*CreateConsumerRequest) ProtoMessage()

func (*CreateConsumerRequest) ProtoReflect 

func (x *CreateConsumerRequest) ProtoReflect() protoreflect.Message

func (*CreateConsumerRequest) Reset 

func (x *CreateConsumerRequest) Reset()

func (*CreateConsumerRequest) String 

func (x *CreateConsumerRequest) String() string

type CreateConsumerResponse 

type CreateConsumerResponse struct {
	Item *v1.Consumer `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateConsumerResponse) Descriptor deprecated 

func (*CreateConsumerResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateConsumerResponse.ProtoReflect.Descriptor instead.

func (*CreateConsumerResponse) GetItem 

func (x *CreateConsumerResponse) GetItem() *v1.Consumer

func (*CreateConsumerResponse) ProtoMessage 

func (*CreateConsumerResponse) ProtoMessage()

func (*CreateConsumerResponse) ProtoReflect 

func (x *CreateConsumerResponse) ProtoReflect() protoreflect.Message

func (*CreateConsumerResponse) Reset 

func (x *CreateConsumerResponse) Reset()

func (*CreateConsumerResponse) String 

func (x *CreateConsumerResponse) String() string

type CreateLuaPluginSchemaRequest 

type CreateLuaPluginSchemaRequest struct {
	Item    *v1.PluginSchema   `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateLuaPluginSchemaRequest) Descriptor deprecated 

func (*CreateLuaPluginSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateLuaPluginSchemaRequest.ProtoReflect.Descriptor instead.

func (*CreateLuaPluginSchemaRequest) GetCluster 

func (x *CreateLuaPluginSchemaRequest) GetCluster() *v1.RequestCluster

func (*CreateLuaPluginSchemaRequest) GetItem 

func (x *CreateLuaPluginSchemaRequest) GetItem() *v1.PluginSchema

func (*CreateLuaPluginSchemaRequest) ProtoMessage 

func (*CreateLuaPluginSchemaRequest) ProtoMessage()

func (*CreateLuaPluginSchemaRequest) ProtoReflect 

func (x *CreateLuaPluginSchemaRequest) ProtoReflect() protoreflect.Message

func (*CreateLuaPluginSchemaRequest) Reset 

func (x *CreateLuaPluginSchemaRequest) Reset()

func (*CreateLuaPluginSchemaRequest) String 

func (x *CreateLuaPluginSchemaRequest) String() string

type CreateLuaPluginSchemaResponse 

type CreateLuaPluginSchemaResponse struct {
	Item *v1.PluginSchema `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateLuaPluginSchemaResponse) Descriptor deprecated 

func (*CreateLuaPluginSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateLuaPluginSchemaResponse.ProtoReflect.Descriptor instead.

func (*CreateLuaPluginSchemaResponse) GetItem 

func (x *CreateLuaPluginSchemaResponse) GetItem() *v1.PluginSchema

func (*CreateLuaPluginSchemaResponse) ProtoMessage 

func (*CreateLuaPluginSchemaResponse) ProtoMessage()

func (*CreateLuaPluginSchemaResponse) ProtoReflect 

func (x *CreateLuaPluginSchemaResponse) ProtoReflect() protoreflect.Message

func (*CreateLuaPluginSchemaResponse) Reset 

func (x *CreateLuaPluginSchemaResponse) Reset()

func (*CreateLuaPluginSchemaResponse) String 

func (x *CreateLuaPluginSchemaResponse) String() string

type CreateNodeRequest 

type CreateNodeRequest struct {
	Item    *v1.Node           `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateNodeRequest) Descriptor deprecated 

func (*CreateNodeRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateNodeRequest.ProtoReflect.Descriptor instead.

func (*CreateNodeRequest) GetCluster 

func (x *CreateNodeRequest) GetCluster() *v1.RequestCluster

func (*CreateNodeRequest) GetItem 

func (x *CreateNodeRequest) GetItem() *v1.Node

func (*CreateNodeRequest) ProtoMessage 

func (*CreateNodeRequest) ProtoMessage()

func (*CreateNodeRequest) ProtoReflect 

func (x *CreateNodeRequest) ProtoReflect() protoreflect.Message

func (*CreateNodeRequest) Reset 

func (x *CreateNodeRequest) Reset()

func (*CreateNodeRequest) String 

func (x *CreateNodeRequest) String() string

type CreateNodeResponse 

type CreateNodeResponse struct {
	Item *v1.Node `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateNodeResponse) Descriptor deprecated 

func (*CreateNodeResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateNodeResponse.ProtoReflect.Descriptor instead.

func (*CreateNodeResponse) GetItem 

func (x *CreateNodeResponse) GetItem() *v1.Node

func (*CreateNodeResponse) ProtoMessage 

func (*CreateNodeResponse) ProtoMessage()

func (*CreateNodeResponse) ProtoReflect 

func (x *CreateNodeResponse) ProtoReflect() protoreflect.Message

func (*CreateNodeResponse) Reset 

func (x *CreateNodeResponse) Reset()

func (*CreateNodeResponse) String 

func (x *CreateNodeResponse) String() string

type CreatePluginRequest 

type CreatePluginRequest struct {
	Item    *v1.Plugin         `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*CreatePluginRequest) Descriptor deprecated 

func (*CreatePluginRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreatePluginRequest.ProtoReflect.Descriptor instead.

func (*CreatePluginRequest) GetCluster 

func (x *CreatePluginRequest) GetCluster() *v1.RequestCluster

func (*CreatePluginRequest) GetItem 

func (x *CreatePluginRequest) GetItem() *v1.Plugin

func (*CreatePluginRequest) ProtoMessage 

func (*CreatePluginRequest) ProtoMessage()

func (*CreatePluginRequest) ProtoReflect 

func (x *CreatePluginRequest) ProtoReflect() protoreflect.Message

func (*CreatePluginRequest) Reset 

func (x *CreatePluginRequest) Reset()

func (*CreatePluginRequest) String 

func (x *CreatePluginRequest) String() string

type CreatePluginResponse 

type CreatePluginResponse struct {
	Item *v1.Plugin `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*CreatePluginResponse) Descriptor deprecated 

func (*CreatePluginResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreatePluginResponse.ProtoReflect.Descriptor instead.

func (*CreatePluginResponse) GetItem 

func (x *CreatePluginResponse) GetItem() *v1.Plugin

func (*CreatePluginResponse) ProtoMessage 

func (*CreatePluginResponse) ProtoMessage()

func (*CreatePluginResponse) ProtoReflect 

func (x *CreatePluginResponse) ProtoReflect() protoreflect.Message

func (*CreatePluginResponse) Reset 

func (x *CreatePluginResponse) Reset()

func (*CreatePluginResponse) String 

func (x *CreatePluginResponse) String() string

type CreateRouteRequest 

type CreateRouteRequest struct {
	Item    *v1.Route          `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateRouteRequest) Descriptor deprecated 

func (*CreateRouteRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateRouteRequest.ProtoReflect.Descriptor instead.

func (*CreateRouteRequest) GetCluster 

func (x *CreateRouteRequest) GetCluster() *v1.RequestCluster

func (*CreateRouteRequest) GetItem 

func (x *CreateRouteRequest) GetItem() *v1.Route

func (*CreateRouteRequest) ProtoMessage 

func (*CreateRouteRequest) ProtoMessage()

func (*CreateRouteRequest) ProtoReflect 

func (x *CreateRouteRequest) ProtoReflect() protoreflect.Message

func (*CreateRouteRequest) Reset 

func (x *CreateRouteRequest) Reset()

func (*CreateRouteRequest) String 

func (x *CreateRouteRequest) String() string

type CreateRouteResponse 

type CreateRouteResponse struct {
	Item *v1.Route `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateRouteResponse) Descriptor deprecated 

func (*CreateRouteResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateRouteResponse.ProtoReflect.Descriptor instead.

func (*CreateRouteResponse) GetItem 

func (x *CreateRouteResponse) GetItem() *v1.Route

func (*CreateRouteResponse) ProtoMessage 

func (*CreateRouteResponse) ProtoMessage()

func (*CreateRouteResponse) ProtoReflect 

func (x *CreateRouteResponse) ProtoReflect() protoreflect.Message

func (*CreateRouteResponse) Reset 

func (x *CreateRouteResponse) Reset()

func (*CreateRouteResponse) String 

func (x *CreateRouteResponse) String() string

type CreateSNIRequest 

type CreateSNIRequest struct {
	Item    *v1.SNI            `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateSNIRequest) Descriptor deprecated 

func (*CreateSNIRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateSNIRequest.ProtoReflect.Descriptor instead.

func (*CreateSNIRequest) GetCluster 

func (x *CreateSNIRequest) GetCluster() *v1.RequestCluster

func (*CreateSNIRequest) GetItem 

func (x *CreateSNIRequest) GetItem() *v1.SNI

func (*CreateSNIRequest) ProtoMessage 

func (*CreateSNIRequest) ProtoMessage()

func (*CreateSNIRequest) ProtoReflect 

func (x *CreateSNIRequest) ProtoReflect() protoreflect.Message

func (*CreateSNIRequest) Reset 

func (x *CreateSNIRequest) Reset()

func (*CreateSNIRequest) String 

func (x *CreateSNIRequest) String() string

type CreateSNIResponse 

type CreateSNIResponse struct {
	Item *v1.SNI `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateSNIResponse) Descriptor deprecated 

func (*CreateSNIResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateSNIResponse.ProtoReflect.Descriptor instead.

func (*CreateSNIResponse) GetItem 

func (x *CreateSNIResponse) GetItem() *v1.SNI

func (*CreateSNIResponse) ProtoMessage 

func (*CreateSNIResponse) ProtoMessage()

func (*CreateSNIResponse) ProtoReflect 

func (x *CreateSNIResponse) ProtoReflect() protoreflect.Message

func (*CreateSNIResponse) Reset 

func (x *CreateSNIResponse) Reset()

func (*CreateSNIResponse) String 

func (x *CreateSNIResponse) String() string

type CreateServiceRequest 

type CreateServiceRequest struct {
	Item    *v1.Service        `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateServiceRequest) Descriptor deprecated 

func (*CreateServiceRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateServiceRequest.ProtoReflect.Descriptor instead.

func (*CreateServiceRequest) GetCluster 

func (x *CreateServiceRequest) GetCluster() *v1.RequestCluster

func (*CreateServiceRequest) GetItem 

func (x *CreateServiceRequest) GetItem() *v1.Service

func (*CreateServiceRequest) ProtoMessage 

func (*CreateServiceRequest) ProtoMessage()

func (*CreateServiceRequest) ProtoReflect 

func (x *CreateServiceRequest) ProtoReflect() protoreflect.Message

func (*CreateServiceRequest) Reset 

func (x *CreateServiceRequest) Reset()

func (*CreateServiceRequest) String 

func (x *CreateServiceRequest) String() string

type CreateServiceResponse 

type CreateServiceResponse struct {
	Item *v1.Service `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateServiceResponse) Descriptor deprecated 

func (*CreateServiceResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateServiceResponse.ProtoReflect.Descriptor instead.

func (*CreateServiceResponse) GetItem 

func (x *CreateServiceResponse) GetItem() *v1.Service

func (*CreateServiceResponse) ProtoMessage 

func (*CreateServiceResponse) ProtoMessage()

func (*CreateServiceResponse) ProtoReflect 

func (x *CreateServiceResponse) ProtoReflect() protoreflect.Message

func (*CreateServiceResponse) Reset 

func (x *CreateServiceResponse) Reset()

func (*CreateServiceResponse) String 

func (x *CreateServiceResponse) String() string

type CreateTargetRequest 

type CreateTargetRequest struct {
	Item    *v1.Target         `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateTargetRequest) Descriptor deprecated 

func (*CreateTargetRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateTargetRequest.ProtoReflect.Descriptor instead.

func (*CreateTargetRequest) GetCluster 

func (x *CreateTargetRequest) GetCluster() *v1.RequestCluster

func (*CreateTargetRequest) GetItem 

func (x *CreateTargetRequest) GetItem() *v1.Target

func (*CreateTargetRequest) ProtoMessage 

func (*CreateTargetRequest) ProtoMessage()

func (*CreateTargetRequest) ProtoReflect 

func (x *CreateTargetRequest) ProtoReflect() protoreflect.Message

func (*CreateTargetRequest) Reset 

func (x *CreateTargetRequest) Reset()

func (*CreateTargetRequest) String 

func (x *CreateTargetRequest) String() string

type CreateTargetResponse 

type CreateTargetResponse struct {
	Item *v1.Target `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateTargetResponse) Descriptor deprecated 

func (*CreateTargetResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateTargetResponse.ProtoReflect.Descriptor instead.

func (*CreateTargetResponse) GetItem 

func (x *CreateTargetResponse) GetItem() *v1.Target

func (*CreateTargetResponse) ProtoMessage 

func (*CreateTargetResponse) ProtoMessage()

func (*CreateTargetResponse) ProtoReflect 

func (x *CreateTargetResponse) ProtoReflect() protoreflect.Message

func (*CreateTargetResponse) Reset 

func (x *CreateTargetResponse) Reset()

func (*CreateTargetResponse) String 

func (x *CreateTargetResponse) String() string

type CreateUpstreamRequest 

type CreateUpstreamRequest struct {
	Item    *v1.Upstream       `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateUpstreamRequest) Descriptor deprecated 

func (*CreateUpstreamRequest) Descriptor() ([]byte, []int)

Deprecated: Use CreateUpstreamRequest.ProtoReflect.Descriptor instead.

func (*CreateUpstreamRequest) GetCluster 

func (x *CreateUpstreamRequest) GetCluster() *v1.RequestCluster

func (*CreateUpstreamRequest) GetItem 

func (x *CreateUpstreamRequest) GetItem() *v1.Upstream

func (*CreateUpstreamRequest) ProtoMessage 

func (*CreateUpstreamRequest) ProtoMessage()

func (*CreateUpstreamRequest) ProtoReflect 

func (x *CreateUpstreamRequest) ProtoReflect() protoreflect.Message

func (*CreateUpstreamRequest) Reset 

func (x *CreateUpstreamRequest) Reset()

func (*CreateUpstreamRequest) String 

func (x *CreateUpstreamRequest) String() string

type CreateUpstreamResponse 

type CreateUpstreamResponse struct {
	Item *v1.Upstream `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateUpstreamResponse) Descriptor deprecated 

func (*CreateUpstreamResponse) Descriptor() ([]byte, []int)

Deprecated: Use CreateUpstreamResponse.ProtoReflect.Descriptor instead.

func (*CreateUpstreamResponse) GetItem 

func (x *CreateUpstreamResponse) GetItem() *v1.Upstream

func (*CreateUpstreamResponse) ProtoMessage 

func (*CreateUpstreamResponse) ProtoMessage()

func (*CreateUpstreamResponse) ProtoReflect 

func (x *CreateUpstreamResponse) ProtoReflect() protoreflect.Message

func (*CreateUpstreamResponse) Reset 

func (x *CreateUpstreamResponse) Reset()

func (*CreateUpstreamResponse) String 

func (x *CreateUpstreamResponse) String() string

type DeleteCACertificateRequest 

type DeleteCACertificateRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteCACertificateRequest) Descriptor deprecated 

func (*DeleteCACertificateRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteCACertificateRequest.ProtoReflect.Descriptor instead.

func (*DeleteCACertificateRequest) GetCluster 

func (x *DeleteCACertificateRequest) GetCluster() *v1.RequestCluster

func (*DeleteCACertificateRequest) GetId 

func (x *DeleteCACertificateRequest) GetId() string

func (*DeleteCACertificateRequest) ProtoMessage 

func (*DeleteCACertificateRequest) ProtoMessage()

func (*DeleteCACertificateRequest) ProtoReflect 

func (x *DeleteCACertificateRequest) ProtoReflect() protoreflect.Message

func (*DeleteCACertificateRequest) Reset 

func (x *DeleteCACertificateRequest) Reset()

func (*DeleteCACertificateRequest) String 

func (x *DeleteCACertificateRequest) String() string

type DeleteCACertificateResponse 

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

func (*DeleteCACertificateResponse) Descriptor deprecated 

func (*DeleteCACertificateResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteCACertificateResponse.ProtoReflect.Descriptor instead.

func (*DeleteCACertificateResponse) ProtoMessage 

func (*DeleteCACertificateResponse) ProtoMessage()

func (*DeleteCACertificateResponse) ProtoReflect 

func (x *DeleteCACertificateResponse) ProtoReflect() protoreflect.Message

func (*DeleteCACertificateResponse) Reset 

func (x *DeleteCACertificateResponse) Reset()

func (*DeleteCACertificateResponse) String 

func (x *DeleteCACertificateResponse) String() string

type DeleteCertificateRequest 

type DeleteCertificateRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteCertificateRequest) Descriptor deprecated 

func (*DeleteCertificateRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteCertificateRequest.ProtoReflect.Descriptor instead.

func (*DeleteCertificateRequest) GetCluster 

func (x *DeleteCertificateRequest) GetCluster() *v1.RequestCluster

func (*DeleteCertificateRequest) GetId 

func (x *DeleteCertificateRequest) GetId() string

func (*DeleteCertificateRequest) ProtoMessage 

func (*DeleteCertificateRequest) ProtoMessage()

func (*DeleteCertificateRequest) ProtoReflect 

func (x *DeleteCertificateRequest) ProtoReflect() protoreflect.Message

func (*DeleteCertificateRequest) Reset 

func (x *DeleteCertificateRequest) Reset()

func (*DeleteCertificateRequest) String 

func (x *DeleteCertificateRequest) String() string

type DeleteCertificateResponse 

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

func (*DeleteCertificateResponse) Descriptor deprecated 

func (*DeleteCertificateResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteCertificateResponse.ProtoReflect.Descriptor instead.

func (*DeleteCertificateResponse) ProtoMessage 

func (*DeleteCertificateResponse) ProtoMessage()

func (*DeleteCertificateResponse) ProtoReflect 

func (x *DeleteCertificateResponse) ProtoReflect() protoreflect.Message

func (*DeleteCertificateResponse) Reset 

func (x *DeleteCertificateResponse) Reset()

func (*DeleteCertificateResponse) String 

func (x *DeleteCertificateResponse) String() string

type DeleteConsumerRequest 

type DeleteConsumerRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteConsumerRequest) Descriptor deprecated 

func (*DeleteConsumerRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteConsumerRequest.ProtoReflect.Descriptor instead.

func (*DeleteConsumerRequest) GetCluster 

func (x *DeleteConsumerRequest) GetCluster() *v1.RequestCluster

func (*DeleteConsumerRequest) GetId 

func (x *DeleteConsumerRequest) GetId() string

func (*DeleteConsumerRequest) ProtoMessage 

func (*DeleteConsumerRequest) ProtoMessage()

func (*DeleteConsumerRequest) ProtoReflect 

func (x *DeleteConsumerRequest) ProtoReflect() protoreflect.Message

func (*DeleteConsumerRequest) Reset 

func (x *DeleteConsumerRequest) Reset()

func (*DeleteConsumerRequest) String 

func (x *DeleteConsumerRequest) String() string

type DeleteConsumerResponse 

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

func (*DeleteConsumerResponse) Descriptor deprecated 

func (*DeleteConsumerResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteConsumerResponse.ProtoReflect.Descriptor instead.

func (*DeleteConsumerResponse) ProtoMessage 

func (*DeleteConsumerResponse) ProtoMessage()

func (*DeleteConsumerResponse) ProtoReflect 

func (x *DeleteConsumerResponse) ProtoReflect() protoreflect.Message

func (*DeleteConsumerResponse) Reset 

func (x *DeleteConsumerResponse) Reset()

func (*DeleteConsumerResponse) String 

func (x *DeleteConsumerResponse) String() string

type DeleteLuaPluginSchemaRequest 

type DeleteLuaPluginSchemaRequest struct {
	Name    string             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteLuaPluginSchemaRequest) Descriptor deprecated 

func (*DeleteLuaPluginSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteLuaPluginSchemaRequest.ProtoReflect.Descriptor instead.

func (*DeleteLuaPluginSchemaRequest) GetCluster 

func (x *DeleteLuaPluginSchemaRequest) GetCluster() *v1.RequestCluster

func (*DeleteLuaPluginSchemaRequest) GetName 

func (x *DeleteLuaPluginSchemaRequest) GetName() string

func (*DeleteLuaPluginSchemaRequest) ProtoMessage 

func (*DeleteLuaPluginSchemaRequest) ProtoMessage()

func (*DeleteLuaPluginSchemaRequest) ProtoReflect 

func (x *DeleteLuaPluginSchemaRequest) ProtoReflect() protoreflect.Message

func (*DeleteLuaPluginSchemaRequest) Reset 

func (x *DeleteLuaPluginSchemaRequest) Reset()

func (*DeleteLuaPluginSchemaRequest) String 

func (x *DeleteLuaPluginSchemaRequest) String() string

type DeleteLuaPluginSchemaResponse 

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

func (*DeleteLuaPluginSchemaResponse) Descriptor deprecated 

func (*DeleteLuaPluginSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteLuaPluginSchemaResponse.ProtoReflect.Descriptor instead.

func (*DeleteLuaPluginSchemaResponse) ProtoMessage 

func (*DeleteLuaPluginSchemaResponse) ProtoMessage()

func (*DeleteLuaPluginSchemaResponse) ProtoReflect 

func (x *DeleteLuaPluginSchemaResponse) ProtoReflect() protoreflect.Message

func (*DeleteLuaPluginSchemaResponse) Reset 

func (x *DeleteLuaPluginSchemaResponse) Reset()

func (*DeleteLuaPluginSchemaResponse) String 

func (x *DeleteLuaPluginSchemaResponse) String() string

type DeleteNodeRequest 

type DeleteNodeRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteNodeRequest) Descriptor deprecated 

func (*DeleteNodeRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteNodeRequest.ProtoReflect.Descriptor instead.

func (*DeleteNodeRequest) GetCluster 

func (x *DeleteNodeRequest) GetCluster() *v1.RequestCluster

func (*DeleteNodeRequest) GetId 

func (x *DeleteNodeRequest) GetId() string

func (*DeleteNodeRequest) ProtoMessage 

func (*DeleteNodeRequest) ProtoMessage()

func (*DeleteNodeRequest) ProtoReflect 

func (x *DeleteNodeRequest) ProtoReflect() protoreflect.Message

func (*DeleteNodeRequest) Reset 

func (x *DeleteNodeRequest) Reset()

func (*DeleteNodeRequest) String 

func (x *DeleteNodeRequest) String() string

type DeleteNodeResponse 

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

func (*DeleteNodeResponse) Descriptor deprecated 

func (*DeleteNodeResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteNodeResponse.ProtoReflect.Descriptor instead.

func (*DeleteNodeResponse) ProtoMessage 

func (*DeleteNodeResponse) ProtoMessage()

func (*DeleteNodeResponse) ProtoReflect 

func (x *DeleteNodeResponse) ProtoReflect() protoreflect.Message

func (*DeleteNodeResponse) Reset 

func (x *DeleteNodeResponse) Reset()

func (*DeleteNodeResponse) String 

func (x *DeleteNodeResponse) String() string

type DeletePluginRequest 

type DeletePluginRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*DeletePluginRequest) Descriptor deprecated 

func (*DeletePluginRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeletePluginRequest.ProtoReflect.Descriptor instead.

func (*DeletePluginRequest) GetCluster 

func (x *DeletePluginRequest) GetCluster() *v1.RequestCluster

func (*DeletePluginRequest) GetId 

func (x *DeletePluginRequest) GetId() string

func (*DeletePluginRequest) ProtoMessage 

func (*DeletePluginRequest) ProtoMessage()

func (*DeletePluginRequest) ProtoReflect 

func (x *DeletePluginRequest) ProtoReflect() protoreflect.Message

func (*DeletePluginRequest) Reset 

func (x *DeletePluginRequest) Reset()

func (*DeletePluginRequest) String 

func (x *DeletePluginRequest) String() string

type DeletePluginResponse 

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

func (*DeletePluginResponse) Descriptor deprecated 

func (*DeletePluginResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeletePluginResponse.ProtoReflect.Descriptor instead.

func (*DeletePluginResponse) ProtoMessage 

func (*DeletePluginResponse) ProtoMessage()

func (*DeletePluginResponse) ProtoReflect 

func (x *DeletePluginResponse) ProtoReflect() protoreflect.Message

func (*DeletePluginResponse) Reset 

func (x *DeletePluginResponse) Reset()

func (*DeletePluginResponse) String 

func (x *DeletePluginResponse) String() string

type DeleteRouteRequest 

type DeleteRouteRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteRouteRequest) Descriptor deprecated 

func (*DeleteRouteRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteRouteRequest.ProtoReflect.Descriptor instead.

func (*DeleteRouteRequest) GetCluster 

func (x *DeleteRouteRequest) GetCluster() *v1.RequestCluster

func (*DeleteRouteRequest) GetId 

func (x *DeleteRouteRequest) GetId() string

func (*DeleteRouteRequest) ProtoMessage 

func (*DeleteRouteRequest) ProtoMessage()

func (*DeleteRouteRequest) ProtoReflect 

func (x *DeleteRouteRequest) ProtoReflect() protoreflect.Message

func (*DeleteRouteRequest) Reset 

func (x *DeleteRouteRequest) Reset()

func (*DeleteRouteRequest) String 

func (x *DeleteRouteRequest) String() string

type DeleteRouteResponse 

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

func (*DeleteRouteResponse) Descriptor deprecated 

func (*DeleteRouteResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteRouteResponse.ProtoReflect.Descriptor instead.

func (*DeleteRouteResponse) ProtoMessage 

func (*DeleteRouteResponse) ProtoMessage()

func (*DeleteRouteResponse) ProtoReflect 

func (x *DeleteRouteResponse) ProtoReflect() protoreflect.Message

func (*DeleteRouteResponse) Reset 

func (x *DeleteRouteResponse) Reset()

func (*DeleteRouteResponse) String 

func (x *DeleteRouteResponse) String() string

type DeleteSNIRequest 

type DeleteSNIRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteSNIRequest) Descriptor deprecated 

func (*DeleteSNIRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteSNIRequest.ProtoReflect.Descriptor instead.

func (*DeleteSNIRequest) GetCluster 

func (x *DeleteSNIRequest) GetCluster() *v1.RequestCluster

func (*DeleteSNIRequest) GetId 

func (x *DeleteSNIRequest) GetId() string

func (*DeleteSNIRequest) ProtoMessage 

func (*DeleteSNIRequest) ProtoMessage()

func (*DeleteSNIRequest) ProtoReflect 

func (x *DeleteSNIRequest) ProtoReflect() protoreflect.Message

func (*DeleteSNIRequest) Reset 

func (x *DeleteSNIRequest) Reset()

func (*DeleteSNIRequest) String 

func (x *DeleteSNIRequest) String() string

type DeleteSNIResponse 

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

func (*DeleteSNIResponse) Descriptor deprecated 

func (*DeleteSNIResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteSNIResponse.ProtoReflect.Descriptor instead.

func (*DeleteSNIResponse) ProtoMessage 

func (*DeleteSNIResponse) ProtoMessage()

func (*DeleteSNIResponse) ProtoReflect 

func (x *DeleteSNIResponse) ProtoReflect() protoreflect.Message

func (*DeleteSNIResponse) Reset 

func (x *DeleteSNIResponse) Reset()

func (*DeleteSNIResponse) String 

func (x *DeleteSNIResponse) String() string

type DeleteServiceRequest 

type DeleteServiceRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteServiceRequest) Descriptor deprecated 

func (*DeleteServiceRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteServiceRequest.ProtoReflect.Descriptor instead.

func (*DeleteServiceRequest) GetCluster 

func (x *DeleteServiceRequest) GetCluster() *v1.RequestCluster

func (*DeleteServiceRequest) GetId 

func (x *DeleteServiceRequest) GetId() string

func (*DeleteServiceRequest) ProtoMessage 

func (*DeleteServiceRequest) ProtoMessage()

func (*DeleteServiceRequest) ProtoReflect 

func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message

func (*DeleteServiceRequest) Reset 

func (x *DeleteServiceRequest) Reset()

func (*DeleteServiceRequest) String 

func (x *DeleteServiceRequest) String() string

type DeleteServiceResponse 

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

func (*DeleteServiceResponse) Descriptor deprecated 

func (*DeleteServiceResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteServiceResponse.ProtoReflect.Descriptor instead.

func (*DeleteServiceResponse) ProtoMessage 

func (*DeleteServiceResponse) ProtoMessage()

func (*DeleteServiceResponse) ProtoReflect 

func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message

func (*DeleteServiceResponse) Reset 

func (x *DeleteServiceResponse) Reset()

func (*DeleteServiceResponse) String 

func (x *DeleteServiceResponse) String() string

type DeleteTargetRequest 

type DeleteTargetRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteTargetRequest) Descriptor deprecated 

func (*DeleteTargetRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteTargetRequest.ProtoReflect.Descriptor instead.

func (*DeleteTargetRequest) GetCluster 

func (x *DeleteTargetRequest) GetCluster() *v1.RequestCluster

func (*DeleteTargetRequest) GetId 

func (x *DeleteTargetRequest) GetId() string

func (*DeleteTargetRequest) ProtoMessage 

func (*DeleteTargetRequest) ProtoMessage()

func (*DeleteTargetRequest) ProtoReflect 

func (x *DeleteTargetRequest) ProtoReflect() protoreflect.Message

func (*DeleteTargetRequest) Reset 

func (x *DeleteTargetRequest) Reset()

func (*DeleteTargetRequest) String 

func (x *DeleteTargetRequest) String() string

type DeleteTargetResponse 

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

func (*DeleteTargetResponse) Descriptor deprecated 

func (*DeleteTargetResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteTargetResponse.ProtoReflect.Descriptor instead.

func (*DeleteTargetResponse) ProtoMessage 

func (*DeleteTargetResponse) ProtoMessage()

func (*DeleteTargetResponse) ProtoReflect 

func (x *DeleteTargetResponse) ProtoReflect() protoreflect.Message

func (*DeleteTargetResponse) Reset 

func (x *DeleteTargetResponse) Reset()

func (*DeleteTargetResponse) String 

func (x *DeleteTargetResponse) String() string

type DeleteUpstreamRequest 

type DeleteUpstreamRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*DeleteUpstreamRequest) Descriptor deprecated 

func (*DeleteUpstreamRequest) Descriptor() ([]byte, []int)

Deprecated: Use DeleteUpstreamRequest.ProtoReflect.Descriptor instead.

func (*DeleteUpstreamRequest) GetCluster 

func (x *DeleteUpstreamRequest) GetCluster() *v1.RequestCluster

func (*DeleteUpstreamRequest) GetId 

func (x *DeleteUpstreamRequest) GetId() string

func (*DeleteUpstreamRequest) ProtoMessage 

func (*DeleteUpstreamRequest) ProtoMessage()

func (*DeleteUpstreamRequest) ProtoReflect 

func (x *DeleteUpstreamRequest) ProtoReflect() protoreflect.Message

func (*DeleteUpstreamRequest) Reset 

func (x *DeleteUpstreamRequest) Reset()

func (*DeleteUpstreamRequest) String 

func (x *DeleteUpstreamRequest) String() string

type DeleteUpstreamResponse 

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

func (*DeleteUpstreamResponse) Descriptor deprecated 

func (*DeleteUpstreamResponse) Descriptor() ([]byte, []int)

Deprecated: Use DeleteUpstreamResponse.ProtoReflect.Descriptor instead.

func (*DeleteUpstreamResponse) ProtoMessage 

func (*DeleteUpstreamResponse) ProtoMessage()

func (*DeleteUpstreamResponse) ProtoReflect 

func (x *DeleteUpstreamResponse) ProtoReflect() protoreflect.Message

func (*DeleteUpstreamResponse) Reset 

func (x *DeleteUpstreamResponse) Reset()

func (*DeleteUpstreamResponse) String 

func (x *DeleteUpstreamResponse) String() string

type GetAvailablePluginsRequest 

type GetAvailablePluginsRequest struct {
	Cluster *v1.RequestCluster `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetAvailablePluginsRequest) Descriptor deprecated 

func (*GetAvailablePluginsRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetAvailablePluginsRequest.ProtoReflect.Descriptor instead.

func (*GetAvailablePluginsRequest) GetCluster 

func (x *GetAvailablePluginsRequest) GetCluster() *v1.RequestCluster

func (*GetAvailablePluginsRequest) ProtoMessage 

func (*GetAvailablePluginsRequest) ProtoMessage()

func (*GetAvailablePluginsRequest) ProtoReflect 

func (x *GetAvailablePluginsRequest) ProtoReflect() protoreflect.Message

func (*GetAvailablePluginsRequest) Reset 

func (x *GetAvailablePluginsRequest) Reset()

func (*GetAvailablePluginsRequest) String 

func (x *GetAvailablePluginsRequest) String() string

type GetAvailablePluginsResponse 

type GetAvailablePluginsResponse struct {
	Names []string `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"`
	// contains filtered or unexported fields
}

func (*GetAvailablePluginsResponse) Descriptor deprecated 

func (*GetAvailablePluginsResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetAvailablePluginsResponse.ProtoReflect.Descriptor instead.

func (*GetAvailablePluginsResponse) GetNames 

func (x *GetAvailablePluginsResponse) GetNames() []string

func (*GetAvailablePluginsResponse) ProtoMessage 

func (*GetAvailablePluginsResponse) ProtoMessage()

func (*GetAvailablePluginsResponse) ProtoReflect 

func (x *GetAvailablePluginsResponse) ProtoReflect() protoreflect.Message

func (*GetAvailablePluginsResponse) Reset 

func (x *GetAvailablePluginsResponse) Reset()

func (*GetAvailablePluginsResponse) String 

func (x *GetAvailablePluginsResponse) String() string

type GetCACertificateRequest 

type GetCACertificateRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetCACertificateRequest) Descriptor deprecated 

func (*GetCACertificateRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetCACertificateRequest.ProtoReflect.Descriptor instead.

func (*GetCACertificateRequest) GetCluster 

func (x *GetCACertificateRequest) GetCluster() *v1.RequestCluster

func (*GetCACertificateRequest) GetId 

func (x *GetCACertificateRequest) GetId() string

func (*GetCACertificateRequest) ProtoMessage 

func (*GetCACertificateRequest) ProtoMessage()

func (*GetCACertificateRequest) ProtoReflect 

func (x *GetCACertificateRequest) ProtoReflect() protoreflect.Message

func (*GetCACertificateRequest) Reset 

func (x *GetCACertificateRequest) Reset()

func (*GetCACertificateRequest) String 

func (x *GetCACertificateRequest) String() string

type GetCACertificateResponse 

type GetCACertificateResponse struct {
	Item *v1.CACertificate `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*GetCACertificateResponse) Descriptor deprecated 

func (*GetCACertificateResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetCACertificateResponse.ProtoReflect.Descriptor instead.

func (*GetCACertificateResponse) GetItem 

func (x *GetCACertificateResponse) GetItem() *v1.CACertificate

func (*GetCACertificateResponse) ProtoMessage 

func (*GetCACertificateResponse) ProtoMessage()

func (*GetCACertificateResponse) ProtoReflect 

func (x *GetCACertificateResponse) ProtoReflect() protoreflect.Message

func (*GetCACertificateResponse) Reset 

func (x *GetCACertificateResponse) Reset()

func (*GetCACertificateResponse) String 

func (x *GetCACertificateResponse) String() string

type GetCertificateRequest 

type GetCertificateRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetCertificateRequest) Descriptor deprecated 

func (*GetCertificateRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetCertificateRequest.ProtoReflect.Descriptor instead.

func (*GetCertificateRequest) GetCluster 

func (x *GetCertificateRequest) GetCluster() *v1.RequestCluster

func (*GetCertificateRequest) GetId 

func (x *GetCertificateRequest) GetId() string

func (*GetCertificateRequest) ProtoMessage 

func (*GetCertificateRequest) ProtoMessage()

func (*GetCertificateRequest) ProtoReflect 

func (x *GetCertificateRequest) ProtoReflect() protoreflect.Message

func (*GetCertificateRequest) Reset 

func (x *GetCertificateRequest) Reset()

func (*GetCertificateRequest) String 

func (x *GetCertificateRequest) String() string

type GetCertificateResponse 

type GetCertificateResponse struct {
	Item *v1.Certificate `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*GetCertificateResponse) Descriptor deprecated 

func (*GetCertificateResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetCertificateResponse.ProtoReflect.Descriptor instead.

func (*GetCertificateResponse) GetItem 

func (x *GetCertificateResponse) GetItem() *v1.Certificate

func (*GetCertificateResponse) ProtoMessage 

func (*GetCertificateResponse) ProtoMessage()

func (*GetCertificateResponse) ProtoReflect 

func (x *GetCertificateResponse) ProtoReflect() protoreflect.Message

func (*GetCertificateResponse) Reset 

func (x *GetCertificateResponse) Reset()

func (*GetCertificateResponse) String 

func (x *GetCertificateResponse) String() string

type GetConfiguredPluginsRequest 

type GetConfiguredPluginsRequest struct {
	Cluster *v1.RequestCluster `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetConfiguredPluginsRequest) Descriptor deprecated 

func (*GetConfiguredPluginsRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetConfiguredPluginsRequest.ProtoReflect.Descriptor instead.

func (*GetConfiguredPluginsRequest) GetCluster 

func (x *GetConfiguredPluginsRequest) GetCluster() *v1.RequestCluster

func (*GetConfiguredPluginsRequest) ProtoMessage 

func (*GetConfiguredPluginsRequest) ProtoMessage()

func (*GetConfiguredPluginsRequest) ProtoReflect 

func (x *GetConfiguredPluginsRequest) ProtoReflect() protoreflect.Message

func (*GetConfiguredPluginsRequest) Reset 

func (x *GetConfiguredPluginsRequest) Reset()

func (*GetConfiguredPluginsRequest) String 

func (x *GetConfiguredPluginsRequest) String() string

type GetConfiguredPluginsResponse 

type GetConfiguredPluginsResponse struct {
	Names []string `protobuf:"bytes,1,rep,name=names,proto3" json:"names,omitempty"`
	// contains filtered or unexported fields
}

func (*GetConfiguredPluginsResponse) Descriptor deprecated 

func (*GetConfiguredPluginsResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetConfiguredPluginsResponse.ProtoReflect.Descriptor instead.

func (*GetConfiguredPluginsResponse) GetNames 

func (x *GetConfiguredPluginsResponse) GetNames() []string

func (*GetConfiguredPluginsResponse) ProtoMessage 

func (*GetConfiguredPluginsResponse) ProtoMessage()

func (*GetConfiguredPluginsResponse) ProtoReflect 

func (x *GetConfiguredPluginsResponse) ProtoReflect() protoreflect.Message

func (*GetConfiguredPluginsResponse) Reset 

func (x *GetConfiguredPluginsResponse) Reset()

func (*GetConfiguredPluginsResponse) String 

func (x *GetConfiguredPluginsResponse) String() string

type GetConsumerRequest 

type GetConsumerRequest struct {
	Id       string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster  *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	CustomId string             `protobuf:"bytes,3,opt,name=custom_id,json=customId,proto3" json:"custom_id,omitempty"`
	// contains filtered or unexported fields
}

func (*GetConsumerRequest) Descriptor deprecated 

func (*GetConsumerRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetConsumerRequest.ProtoReflect.Descriptor instead.

func (*GetConsumerRequest) GetCluster 

func (x *GetConsumerRequest) GetCluster() *v1.RequestCluster

func (*GetConsumerRequest) GetCustomId 

func (x *GetConsumerRequest) GetCustomId() string

func (*GetConsumerRequest) GetId 

func (x *GetConsumerRequest) GetId() string

func (*GetConsumerRequest) ProtoMessage 

func (*GetConsumerRequest) ProtoMessage()

func (*GetConsumerRequest) ProtoReflect 

func (x *GetConsumerRequest) ProtoReflect() protoreflect.Message

func (*GetConsumerRequest) Reset 

func (x *GetConsumerRequest) Reset()

func (*GetConsumerRequest) String 

func (x *GetConsumerRequest) String() string

type GetConsumerResponse 

type GetConsumerResponse struct {
	Item *v1.Consumer `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*GetConsumerResponse) Descriptor deprecated 

func (*GetConsumerResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetConsumerResponse.ProtoReflect.Descriptor instead.

func (*GetConsumerResponse) GetItem 

func (x *GetConsumerResponse) GetItem() *v1.Consumer

func (*GetConsumerResponse) ProtoMessage 

func (*GetConsumerResponse) ProtoMessage()

func (*GetConsumerResponse) ProtoReflect 

func (x *GetConsumerResponse) ProtoReflect() protoreflect.Message

func (*GetConsumerResponse) Reset 

func (x *GetConsumerResponse) Reset()

func (*GetConsumerResponse) String 

func (x *GetConsumerResponse) String() string

type GetHashRequest 

type GetHashRequest struct {
	Cluster *v1.RequestCluster `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetHashRequest) Descriptor deprecated 

func (*GetHashRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetHashRequest.ProtoReflect.Descriptor instead.

func (*GetHashRequest) GetCluster 

func (x *GetHashRequest) GetCluster() *v1.RequestCluster

func (*GetHashRequest) ProtoMessage 

func (*GetHashRequest) ProtoMessage()

func (*GetHashRequest) ProtoReflect 

func (x *GetHashRequest) ProtoReflect() protoreflect.Message

func (*GetHashRequest) Reset 

func (x *GetHashRequest) Reset()

func (*GetHashRequest) String 

func (x *GetHashRequest) String() string

type GetHashResponse 

type GetHashResponse struct {
	ExpectedHash string `protobuf:"bytes,1,opt,name=expected_hash,json=expectedHash,proto3" json:"expected_hash,omitempty"`
	// contains filtered or unexported fields
}

func (*GetHashResponse) Descriptor deprecated 

func (*GetHashResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetHashResponse.ProtoReflect.Descriptor instead.

func (*GetHashResponse) GetExpectedHash 

func (x *GetHashResponse) GetExpectedHash() string

func (*GetHashResponse) ProtoMessage 

func (*GetHashResponse) ProtoMessage()

func (*GetHashResponse) ProtoReflect 

func (x *GetHashResponse) ProtoReflect() protoreflect.Message

func (*GetHashResponse) Reset 

func (x *GetHashResponse) Reset()

func (*GetHashResponse) String 

func (x *GetHashResponse) String() string

type GetLuaPluginSchemaRequest 

type GetLuaPluginSchemaRequest struct {
	Name    string             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetLuaPluginSchemaRequest) Descriptor deprecated 

func (*GetLuaPluginSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetLuaPluginSchemaRequest.ProtoReflect.Descriptor instead.

func (*GetLuaPluginSchemaRequest) GetCluster 

func (x *GetLuaPluginSchemaRequest) GetCluster() *v1.RequestCluster

func (*GetLuaPluginSchemaRequest) GetName 

func (x *GetLuaPluginSchemaRequest) GetName() string

func (*GetLuaPluginSchemaRequest) ProtoMessage 

func (*GetLuaPluginSchemaRequest) ProtoMessage()

func (*GetLuaPluginSchemaRequest) ProtoReflect 

func (x *GetLuaPluginSchemaRequest) ProtoReflect() protoreflect.Message

func (*GetLuaPluginSchemaRequest) Reset 

func (x *GetLuaPluginSchemaRequest) Reset()

func (*GetLuaPluginSchemaRequest) String 

func (x *GetLuaPluginSchemaRequest) String() string

type GetLuaPluginSchemaResponse 

type GetLuaPluginSchemaResponse struct {
	Item *v1.PluginSchema `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*GetLuaPluginSchemaResponse) Descriptor deprecated 

func (*GetLuaPluginSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetLuaPluginSchemaResponse.ProtoReflect.Descriptor instead.

func (*GetLuaPluginSchemaResponse) GetItem 

func (x *GetLuaPluginSchemaResponse) GetItem() *v1.PluginSchema

func (*GetLuaPluginSchemaResponse) ProtoMessage 

func (*GetLuaPluginSchemaResponse) ProtoMessage()

func (*GetLuaPluginSchemaResponse) ProtoReflect 

func (x *GetLuaPluginSchemaResponse) ProtoReflect() protoreflect.Message

func (*GetLuaPluginSchemaResponse) Reset 

func (x *GetLuaPluginSchemaResponse) Reset()

func (*GetLuaPluginSchemaResponse) String 

func (x *GetLuaPluginSchemaResponse) String() string

type GetLuaSchemasPluginRequest 

type GetLuaSchemasPluginRequest struct {
	Name    string             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetLuaSchemasPluginRequest) Descriptor deprecated 

func (*GetLuaSchemasPluginRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetLuaSchemasPluginRequest.ProtoReflect.Descriptor instead.

func (*GetLuaSchemasPluginRequest) GetCluster 

func (x *GetLuaSchemasPluginRequest) GetCluster() *v1.RequestCluster

func (*GetLuaSchemasPluginRequest) GetName 

func (x *GetLuaSchemasPluginRequest) GetName() string

func (*GetLuaSchemasPluginRequest) ProtoMessage 

func (*GetLuaSchemasPluginRequest) ProtoMessage()

func (*GetLuaSchemasPluginRequest) ProtoReflect 

func (x *GetLuaSchemasPluginRequest) ProtoReflect() protoreflect.Message

func (*GetLuaSchemasPluginRequest) Reset 

func (x *GetLuaSchemasPluginRequest) Reset()

func (*GetLuaSchemasPluginRequest) String 

func (x *GetLuaSchemasPluginRequest) String() string

type GetLuaSchemasPluginResponse 

type GetLuaSchemasPluginResponse struct {
	Schema *structpb.Struct `protobuf:"bytes,1,opt,name=schema,proto3" json:"schema,omitempty"`
	// contains filtered or unexported fields
}

func (*GetLuaSchemasPluginResponse) Descriptor deprecated 

func (*GetLuaSchemasPluginResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetLuaSchemasPluginResponse.ProtoReflect.Descriptor instead.

func (*GetLuaSchemasPluginResponse) GetSchema 

func (x *GetLuaSchemasPluginResponse) GetSchema() *structpb.Struct

func (*GetLuaSchemasPluginResponse) ProtoMessage 

func (*GetLuaSchemasPluginResponse) ProtoMessage()

func (*GetLuaSchemasPluginResponse) ProtoReflect 

func (x *GetLuaSchemasPluginResponse) ProtoReflect() protoreflect.Message

func (*GetLuaSchemasPluginResponse) Reset 

func (x *GetLuaSchemasPluginResponse) Reset()

func (*GetLuaSchemasPluginResponse) String 

func (x *GetLuaSchemasPluginResponse) String() string

type GetNodeRequest 

type GetNodeRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetNodeRequest) Descriptor deprecated 

func (*GetNodeRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetNodeRequest.ProtoReflect.Descriptor instead.

func (*GetNodeRequest) GetCluster 

func (x *GetNodeRequest) GetCluster() *v1.RequestCluster

func (*GetNodeRequest) GetId 

func (x *GetNodeRequest) GetId() string

func (*GetNodeRequest) ProtoMessage 

func (*GetNodeRequest) ProtoMessage()

func (*GetNodeRequest) ProtoReflect 

func (x *GetNodeRequest) ProtoReflect() protoreflect.Message

func (*GetNodeRequest) Reset 

func (x *GetNodeRequest) Reset()

func (*GetNodeRequest) String 

func (x *GetNodeRequest) String() string

type GetNodeResponse 

type GetNodeResponse struct {
	Item *v1.Node `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*GetNodeResponse) Descriptor deprecated 

func (*GetNodeResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetNodeResponse.ProtoReflect.Descriptor instead.

func (*GetNodeResponse) GetItem 

func (x *GetNodeResponse) GetItem() *v1.Node

func (*GetNodeResponse) ProtoMessage 

func (*GetNodeResponse) ProtoMessage()

func (*GetNodeResponse) ProtoReflect 

func (x *GetNodeResponse) ProtoReflect() protoreflect.Message

func (*GetNodeResponse) Reset 

func (x *GetNodeResponse) Reset()

func (*GetNodeResponse) String 

func (x *GetNodeResponse) String() string

type GetPluginRequest 

type GetPluginRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetPluginRequest) Descriptor deprecated 

func (*GetPluginRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetPluginRequest.ProtoReflect.Descriptor instead.

func (*GetPluginRequest) GetCluster 

func (x *GetPluginRequest) GetCluster() *v1.RequestCluster

func (*GetPluginRequest) GetId 

func (x *GetPluginRequest) GetId() string

func (*GetPluginRequest) ProtoMessage 

func (*GetPluginRequest) ProtoMessage()

func (*GetPluginRequest) ProtoReflect 

func (x *GetPluginRequest) ProtoReflect() protoreflect.Message

func (*GetPluginRequest) Reset 

func (x *GetPluginRequest) Reset()

func (*GetPluginRequest) String 

func (x *GetPluginRequest) String() string

type GetPluginResponse 

type GetPluginResponse struct {
	Item *v1.Plugin `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*GetPluginResponse) Descriptor deprecated 

func (*GetPluginResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetPluginResponse.ProtoReflect.Descriptor instead.

func (*GetPluginResponse) GetItem 

func (x *GetPluginResponse) GetItem() *v1.Plugin

func (*GetPluginResponse) ProtoMessage 

func (*GetPluginResponse) ProtoMessage()

func (*GetPluginResponse) ProtoReflect 

func (x *GetPluginResponse) ProtoReflect() protoreflect.Message

func (*GetPluginResponse) Reset 

func (x *GetPluginResponse) Reset()

func (*GetPluginResponse) String 

func (x *GetPluginResponse) String() string

type GetRouteRequest 

type GetRouteRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetRouteRequest) Descriptor deprecated 

func (*GetRouteRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetRouteRequest.ProtoReflect.Descriptor instead.

func (*GetRouteRequest) GetCluster 

func (x *GetRouteRequest) GetCluster() *v1.RequestCluster

func (*GetRouteRequest) GetId 

func (x *GetRouteRequest) GetId() string

func (*GetRouteRequest) ProtoMessage 

func (*GetRouteRequest) ProtoMessage()

func (*GetRouteRequest) ProtoReflect 

func (x *GetRouteRequest) ProtoReflect() protoreflect.Message

func (*GetRouteRequest) Reset 

func (x *GetRouteRequest) Reset()

func (*GetRouteRequest) String 

func (x *GetRouteRequest) String() string

type GetRouteResponse 

type GetRouteResponse struct {
	Item *v1.Route `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*GetRouteResponse) Descriptor deprecated 

func (*GetRouteResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetRouteResponse.ProtoReflect.Descriptor instead.

func (*GetRouteResponse) GetItem 

func (x *GetRouteResponse) GetItem() *v1.Route

func (*GetRouteResponse) ProtoMessage 

func (*GetRouteResponse) ProtoMessage()

func (*GetRouteResponse) ProtoReflect 

func (x *GetRouteResponse) ProtoReflect() protoreflect.Message

func (*GetRouteResponse) Reset 

func (x *GetRouteResponse) Reset()

func (*GetRouteResponse) String 

func (x *GetRouteResponse) String() string

type GetSNIRequest 

type GetSNIRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetSNIRequest) Descriptor deprecated 

func (*GetSNIRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetSNIRequest.ProtoReflect.Descriptor instead.

func (*GetSNIRequest) GetCluster 

func (x *GetSNIRequest) GetCluster() *v1.RequestCluster

func (*GetSNIRequest) GetId 

func (x *GetSNIRequest) GetId() string

func (*GetSNIRequest) ProtoMessage 

func (*GetSNIRequest) ProtoMessage()

func (*GetSNIRequest) ProtoReflect 

func (x *GetSNIRequest) ProtoReflect() protoreflect.Message

func (*GetSNIRequest) Reset 

func (x *GetSNIRequest) Reset()

func (*GetSNIRequest) String 

func (x *GetSNIRequest) String() string

type GetSNIResponse 

type GetSNIResponse struct {
	Item *v1.SNI `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*GetSNIResponse) Descriptor deprecated 

func (*GetSNIResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetSNIResponse.ProtoReflect.Descriptor instead.

func (*GetSNIResponse) GetItem 

func (x *GetSNIResponse) GetItem() *v1.SNI

func (*GetSNIResponse) ProtoMessage 

func (*GetSNIResponse) ProtoMessage()

func (*GetSNIResponse) ProtoReflect 

func (x *GetSNIResponse) ProtoReflect() protoreflect.Message

func (*GetSNIResponse) Reset 

func (x *GetSNIResponse) Reset()

func (*GetSNIResponse) String 

func (x *GetSNIResponse) String() string

type GetSchemasRequest 

type GetSchemasRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

func (*GetSchemasRequest) Descriptor deprecated 

func (*GetSchemasRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetSchemasRequest.ProtoReflect.Descriptor instead.

func (*GetSchemasRequest) GetName 

func (x *GetSchemasRequest) GetName() string

func (*GetSchemasRequest) ProtoMessage 

func (*GetSchemasRequest) ProtoMessage()

func (*GetSchemasRequest) ProtoReflect 

func (x *GetSchemasRequest) ProtoReflect() protoreflect.Message

func (*GetSchemasRequest) Reset 

func (x *GetSchemasRequest) Reset()

func (*GetSchemasRequest) String 

func (x *GetSchemasRequest) String() string

type GetSchemasResponse 

type GetSchemasResponse struct {
	Schema *structpb.Struct `protobuf:"bytes,1,opt,name=schema,proto3" json:"schema,omitempty"`
	// contains filtered or unexported fields
}

func (*GetSchemasResponse) Descriptor deprecated 

func (*GetSchemasResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetSchemasResponse.ProtoReflect.Descriptor instead.

func (*GetSchemasResponse) GetSchema 

func (x *GetSchemasResponse) GetSchema() *structpb.Struct

func (*GetSchemasResponse) ProtoMessage 

func (*GetSchemasResponse) ProtoMessage()

func (*GetSchemasResponse) ProtoReflect 

func (x *GetSchemasResponse) ProtoReflect() protoreflect.Message

func (*GetSchemasResponse) Reset 

func (x *GetSchemasResponse) Reset()

func (*GetSchemasResponse) String 

func (x *GetSchemasResponse) String() string

type GetServiceRequest 

type GetServiceRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetServiceRequest) Descriptor deprecated 

func (*GetServiceRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetServiceRequest.ProtoReflect.Descriptor instead.

func (*GetServiceRequest) GetCluster 

func (x *GetServiceRequest) GetCluster() *v1.RequestCluster

func (*GetServiceRequest) GetId 

func (x *GetServiceRequest) GetId() string

func (*GetServiceRequest) ProtoMessage 

func (*GetServiceRequest) ProtoMessage()

func (*GetServiceRequest) ProtoReflect 

func (x *GetServiceRequest) ProtoReflect() protoreflect.Message

func (*GetServiceRequest) Reset 

func (x *GetServiceRequest) Reset()

func (*GetServiceRequest) String 

func (x *GetServiceRequest) String() string

type GetServiceResponse 

type GetServiceResponse struct {
	Item *v1.Service `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*GetServiceResponse) Descriptor deprecated 

func (*GetServiceResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetServiceResponse.ProtoReflect.Descriptor instead.

func (*GetServiceResponse) GetItem 

func (x *GetServiceResponse) GetItem() *v1.Service

func (*GetServiceResponse) ProtoMessage 

func (*GetServiceResponse) ProtoMessage()

func (*GetServiceResponse) ProtoReflect 

func (x *GetServiceResponse) ProtoReflect() protoreflect.Message

func (*GetServiceResponse) Reset 

func (x *GetServiceResponse) Reset()

func (*GetServiceResponse) String 

func (x *GetServiceResponse) String() string

type GetTargetRequest 

type GetTargetRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetTargetRequest) Descriptor deprecated 

func (*GetTargetRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetTargetRequest.ProtoReflect.Descriptor instead.

func (*GetTargetRequest) GetCluster 

func (x *GetTargetRequest) GetCluster() *v1.RequestCluster

func (*GetTargetRequest) GetId 

func (x *GetTargetRequest) GetId() string

func (*GetTargetRequest) ProtoMessage 

func (*GetTargetRequest) ProtoMessage()

func (*GetTargetRequest) ProtoReflect 

func (x *GetTargetRequest) ProtoReflect() protoreflect.Message

func (*GetTargetRequest) Reset 

func (x *GetTargetRequest) Reset()

func (*GetTargetRequest) String 

func (x *GetTargetRequest) String() string

type GetTargetResponse 

type GetTargetResponse struct {
	Item *v1.Target `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*GetTargetResponse) Descriptor deprecated 

func (*GetTargetResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetTargetResponse.ProtoReflect.Descriptor instead.

func (*GetTargetResponse) GetItem 

func (x *GetTargetResponse) GetItem() *v1.Target

func (*GetTargetResponse) ProtoMessage 

func (*GetTargetResponse) ProtoMessage()

func (*GetTargetResponse) ProtoReflect 

func (x *GetTargetResponse) ProtoReflect() protoreflect.Message

func (*GetTargetResponse) Reset 

func (x *GetTargetResponse) Reset()

func (*GetTargetResponse) String 

func (x *GetTargetResponse) String() string

type GetUpstreamRequest 

type GetUpstreamRequest struct {
	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*GetUpstreamRequest) Descriptor deprecated 

func (*GetUpstreamRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetUpstreamRequest.ProtoReflect.Descriptor instead.

func (*GetUpstreamRequest) GetCluster 

func (x *GetUpstreamRequest) GetCluster() *v1.RequestCluster

func (*GetUpstreamRequest) GetId 

func (x *GetUpstreamRequest) GetId() string

func (*GetUpstreamRequest) ProtoMessage 

func (*GetUpstreamRequest) ProtoMessage()

func (*GetUpstreamRequest) ProtoReflect 

func (x *GetUpstreamRequest) ProtoReflect() protoreflect.Message

func (*GetUpstreamRequest) Reset 

func (x *GetUpstreamRequest) Reset()

func (*GetUpstreamRequest) String 

func (x *GetUpstreamRequest) String() string

type GetUpstreamResponse 

type GetUpstreamResponse struct {
	Item *v1.Upstream `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*GetUpstreamResponse) Descriptor deprecated 

func (*GetUpstreamResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetUpstreamResponse.ProtoReflect.Descriptor instead.

func (*GetUpstreamResponse) GetItem 

func (x *GetUpstreamResponse) GetItem() *v1.Upstream

func (*GetUpstreamResponse) ProtoMessage 

func (*GetUpstreamResponse) ProtoMessage()

func (*GetUpstreamResponse) ProtoReflect 

func (x *GetUpstreamResponse) ProtoReflect() protoreflect.Message

func (*GetUpstreamResponse) Reset 

func (x *GetUpstreamResponse) Reset()

func (*GetUpstreamResponse) String 

func (x *GetUpstreamResponse) String() string

type GetVersionRequest 

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

func (*GetVersionRequest) Descriptor deprecated 

func (*GetVersionRequest) Descriptor() ([]byte, []int)

Deprecated: Use GetVersionRequest.ProtoReflect.Descriptor instead.

func (*GetVersionRequest) ProtoMessage 

func (*GetVersionRequest) ProtoMessage()

func (*GetVersionRequest) ProtoReflect 

func (x *GetVersionRequest) ProtoReflect() protoreflect.Message

func (*GetVersionRequest) Reset 

func (x *GetVersionRequest) Reset()

func (*GetVersionRequest) String 

func (x *GetVersionRequest) String() string

type GetVersionResponse 

type GetVersionResponse struct {
	Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	// contains filtered or unexported fields
}

func (*GetVersionResponse) Descriptor deprecated 

func (*GetVersionResponse) Descriptor() ([]byte, []int)

Deprecated: Use GetVersionResponse.ProtoReflect.Descriptor instead.

func (*GetVersionResponse) GetVersion 

func (x *GetVersionResponse) GetVersion() string

func (*GetVersionResponse) ProtoMessage 

func (*GetVersionResponse) ProtoMessage()

func (*GetVersionResponse) ProtoReflect 

func (x *GetVersionResponse) ProtoReflect() protoreflect.Message

func (*GetVersionResponse) Reset 

func (x *GetVersionResponse) Reset()

func (*GetVersionResponse) String 

func (x *GetVersionResponse) String() string

type ListCACertificatesRequest 

type ListCACertificatesRequest struct {
	Cluster *v1.RequestCluster    `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Page    *v1.PaginationRequest `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListCACertificatesRequest) Descriptor deprecated 

func (*ListCACertificatesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListCACertificatesRequest.ProtoReflect.Descriptor instead.

func (*ListCACertificatesRequest) GetCluster 

func (x *ListCACertificatesRequest) GetCluster() *v1.RequestCluster

func (*ListCACertificatesRequest) GetPage 

func (x *ListCACertificatesRequest) GetPage() *v1.PaginationRequest

func (*ListCACertificatesRequest) ProtoMessage 

func (*ListCACertificatesRequest) ProtoMessage()

func (*ListCACertificatesRequest) ProtoReflect 

func (x *ListCACertificatesRequest) ProtoReflect() protoreflect.Message

func (*ListCACertificatesRequest) Reset 

func (x *ListCACertificatesRequest) Reset()

func (*ListCACertificatesRequest) String 

func (x *ListCACertificatesRequest) String() string

type ListCACertificatesResponse 

type ListCACertificatesResponse struct {
	Items []*v1.CACertificate    `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Page  *v1.PaginationResponse `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListCACertificatesResponse) Descriptor deprecated 

func (*ListCACertificatesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListCACertificatesResponse.ProtoReflect.Descriptor instead.

func (*ListCACertificatesResponse) GetItems 

func (x *ListCACertificatesResponse) GetItems() []*v1.CACertificate

func (*ListCACertificatesResponse) GetPage 

func (x *ListCACertificatesResponse) GetPage() *v1.PaginationResponse

func (*ListCACertificatesResponse) ProtoMessage 

func (*ListCACertificatesResponse) ProtoMessage()

func (*ListCACertificatesResponse) ProtoReflect 

func (x *ListCACertificatesResponse) ProtoReflect() protoreflect.Message

func (*ListCACertificatesResponse) Reset 

func (x *ListCACertificatesResponse) Reset()

func (*ListCACertificatesResponse) String 

func (x *ListCACertificatesResponse) String() string

type ListCertificatesRequest 

type ListCertificatesRequest struct {
	Cluster *v1.RequestCluster    `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Page    *v1.PaginationRequest `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListCertificatesRequest) Descriptor deprecated 

func (*ListCertificatesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListCertificatesRequest.ProtoReflect.Descriptor instead.

func (*ListCertificatesRequest) GetCluster 

func (x *ListCertificatesRequest) GetCluster() *v1.RequestCluster

func (*ListCertificatesRequest) GetPage 

func (x *ListCertificatesRequest) GetPage() *v1.PaginationRequest

func (*ListCertificatesRequest) ProtoMessage 

func (*ListCertificatesRequest) ProtoMessage()

func (*ListCertificatesRequest) ProtoReflect 

func (x *ListCertificatesRequest) ProtoReflect() protoreflect.Message

func (*ListCertificatesRequest) Reset 

func (x *ListCertificatesRequest) Reset()

func (*ListCertificatesRequest) String 

func (x *ListCertificatesRequest) String() string

type ListCertificatesResponse 

type ListCertificatesResponse struct {
	Items []*v1.Certificate      `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Page  *v1.PaginationResponse `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListCertificatesResponse) Descriptor deprecated 

func (*ListCertificatesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListCertificatesResponse.ProtoReflect.Descriptor instead.

func (*ListCertificatesResponse) GetItems 

func (x *ListCertificatesResponse) GetItems() []*v1.Certificate

func (*ListCertificatesResponse) GetPage 

func (x *ListCertificatesResponse) GetPage() *v1.PaginationResponse

func (*ListCertificatesResponse) ProtoMessage 

func (*ListCertificatesResponse) ProtoMessage()

func (*ListCertificatesResponse) ProtoReflect 

func (x *ListCertificatesResponse) ProtoReflect() protoreflect.Message

func (*ListCertificatesResponse) Reset 

func (x *ListCertificatesResponse) Reset()

func (*ListCertificatesResponse) String 

func (x *ListCertificatesResponse) String() string

type ListConsumersRequest 

type ListConsumersRequest struct {
	Cluster *v1.RequestCluster    `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Page    *v1.PaginationRequest `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListConsumersRequest) Descriptor deprecated 

func (*ListConsumersRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListConsumersRequest.ProtoReflect.Descriptor instead.

func (*ListConsumersRequest) GetCluster 

func (x *ListConsumersRequest) GetCluster() *v1.RequestCluster

func (*ListConsumersRequest) GetPage 

func (x *ListConsumersRequest) GetPage() *v1.PaginationRequest

func (*ListConsumersRequest) ProtoMessage 

func (*ListConsumersRequest) ProtoMessage()

func (*ListConsumersRequest) ProtoReflect 

func (x *ListConsumersRequest) ProtoReflect() protoreflect.Message

func (*ListConsumersRequest) Reset 

func (x *ListConsumersRequest) Reset()

func (*ListConsumersRequest) String 

func (x *ListConsumersRequest) String() string

type ListConsumersResponse 

type ListConsumersResponse struct {
	Items []*v1.Consumer         `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Page  *v1.PaginationResponse `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListConsumersResponse) Descriptor deprecated 

func (*ListConsumersResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListConsumersResponse.ProtoReflect.Descriptor instead.

func (*ListConsumersResponse) GetItems 

func (x *ListConsumersResponse) GetItems() []*v1.Consumer

func (*ListConsumersResponse) GetPage 

func (x *ListConsumersResponse) GetPage() *v1.PaginationResponse

func (*ListConsumersResponse) ProtoMessage 

func (*ListConsumersResponse) ProtoMessage()

func (*ListConsumersResponse) ProtoReflect 

func (x *ListConsumersResponse) ProtoReflect() protoreflect.Message

func (*ListConsumersResponse) Reset 

func (x *ListConsumersResponse) Reset()

func (*ListConsumersResponse) String 

func (x *ListConsumersResponse) String() string

type ListLuaPluginSchemasRequest 

type ListLuaPluginSchemasRequest struct {
	Cluster *v1.RequestCluster    `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Page    *v1.PaginationRequest `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListLuaPluginSchemasRequest) Descriptor deprecated 

func (*ListLuaPluginSchemasRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListLuaPluginSchemasRequest.ProtoReflect.Descriptor instead.

func (*ListLuaPluginSchemasRequest) GetCluster 

func (x *ListLuaPluginSchemasRequest) GetCluster() *v1.RequestCluster

func (*ListLuaPluginSchemasRequest) GetPage 

func (x *ListLuaPluginSchemasRequest) GetPage() *v1.PaginationRequest

func (*ListLuaPluginSchemasRequest) ProtoMessage 

func (*ListLuaPluginSchemasRequest) ProtoMessage()

func (*ListLuaPluginSchemasRequest) ProtoReflect 

func (x *ListLuaPluginSchemasRequest) ProtoReflect() protoreflect.Message

func (*ListLuaPluginSchemasRequest) Reset 

func (x *ListLuaPluginSchemasRequest) Reset()

func (*ListLuaPluginSchemasRequest) String 

func (x *ListLuaPluginSchemasRequest) String() string

type ListLuaPluginSchemasResponse 

type ListLuaPluginSchemasResponse struct {
	Items []*v1.PluginSchema     `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Page  *v1.PaginationResponse `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListLuaPluginSchemasResponse) Descriptor deprecated 

func (*ListLuaPluginSchemasResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListLuaPluginSchemasResponse.ProtoReflect.Descriptor instead.

func (*ListLuaPluginSchemasResponse) GetItems 

func (x *ListLuaPluginSchemasResponse) GetItems() []*v1.PluginSchema

func (*ListLuaPluginSchemasResponse) GetPage 

func (x *ListLuaPluginSchemasResponse) GetPage() *v1.PaginationResponse

func (*ListLuaPluginSchemasResponse) ProtoMessage 

func (*ListLuaPluginSchemasResponse) ProtoMessage()

func (*ListLuaPluginSchemasResponse) ProtoReflect 

func (x *ListLuaPluginSchemasResponse) ProtoReflect() protoreflect.Message

func (*ListLuaPluginSchemasResponse) Reset 

func (x *ListLuaPluginSchemasResponse) Reset()

func (*ListLuaPluginSchemasResponse) String 

func (x *ListLuaPluginSchemasResponse) String() string

type ListNodesRequest 

type ListNodesRequest struct {
	Cluster *v1.RequestCluster    `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Page    *v1.PaginationRequest `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListNodesRequest) Descriptor deprecated 

func (*ListNodesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListNodesRequest.ProtoReflect.Descriptor instead.

func (*ListNodesRequest) GetCluster 

func (x *ListNodesRequest) GetCluster() *v1.RequestCluster

func (*ListNodesRequest) GetPage 

func (x *ListNodesRequest) GetPage() *v1.PaginationRequest

func (*ListNodesRequest) ProtoMessage 

func (*ListNodesRequest) ProtoMessage()

func (*ListNodesRequest) ProtoReflect 

func (x *ListNodesRequest) ProtoReflect() protoreflect.Message

func (*ListNodesRequest) Reset 

func (x *ListNodesRequest) Reset()

func (*ListNodesRequest) String 

func (x *ListNodesRequest) String() string

type ListNodesResponse 

type ListNodesResponse struct {
	Items []*v1.Node             `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Page  *v1.PaginationResponse `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListNodesResponse) Descriptor deprecated 

func (*ListNodesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListNodesResponse.ProtoReflect.Descriptor instead.

func (*ListNodesResponse) GetItems 

func (x *ListNodesResponse) GetItems() []*v1.Node

func (*ListNodesResponse) GetPage 

func (x *ListNodesResponse) GetPage() *v1.PaginationResponse

func (*ListNodesResponse) ProtoMessage 

func (*ListNodesResponse) ProtoMessage()

func (*ListNodesResponse) ProtoReflect 

func (x *ListNodesResponse) ProtoReflect() protoreflect.Message

func (*ListNodesResponse) Reset 

func (x *ListNodesResponse) Reset()

func (*ListNodesResponse) String 

func (x *ListNodesResponse) String() string

type ListPluginsRequest 

type ListPluginsRequest struct {
	Cluster    *v1.RequestCluster    `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	ServiceId  string                `protobuf:"bytes,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
	RouteId    string                `protobuf:"bytes,3,opt,name=route_id,json=routeId,proto3" json:"route_id,omitempty"`
	Page       *v1.PaginationRequest `protobuf:"bytes,4,opt,name=page,proto3" json:"page,omitempty"`
	ConsumerId string                `protobuf:"bytes,5,opt,name=consumer_id,json=consumerId,proto3" json:"consumer_id,omitempty"`
	// contains filtered or unexported fields
}

func (*ListPluginsRequest) Descriptor deprecated 

func (*ListPluginsRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListPluginsRequest.ProtoReflect.Descriptor instead.

func (*ListPluginsRequest) GetCluster 

func (x *ListPluginsRequest) GetCluster() *v1.RequestCluster

func (*ListPluginsRequest) GetConsumerId 

func (x *ListPluginsRequest) GetConsumerId() string

func (*ListPluginsRequest) GetPage 

func (x *ListPluginsRequest) GetPage() *v1.PaginationRequest

func (*ListPluginsRequest) GetRouteId 

func (x *ListPluginsRequest) GetRouteId() string

func (*ListPluginsRequest) GetServiceId 

func (x *ListPluginsRequest) GetServiceId() string

func (*ListPluginsRequest) ProtoMessage 

func (*ListPluginsRequest) ProtoMessage()

func (*ListPluginsRequest) ProtoReflect 

func (x *ListPluginsRequest) ProtoReflect() protoreflect.Message

func (*ListPluginsRequest) Reset 

func (x *ListPluginsRequest) Reset()

func (*ListPluginsRequest) String 

func (x *ListPluginsRequest) String() string

type ListPluginsResponse 

type ListPluginsResponse struct {
	Items []*v1.Plugin           `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Page  *v1.PaginationResponse `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListPluginsResponse) Descriptor deprecated 

func (*ListPluginsResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListPluginsResponse.ProtoReflect.Descriptor instead.

func (*ListPluginsResponse) GetItems 

func (x *ListPluginsResponse) GetItems() []*v1.Plugin

func (*ListPluginsResponse) GetPage 

func (x *ListPluginsResponse) GetPage() *v1.PaginationResponse

func (*ListPluginsResponse) ProtoMessage 

func (*ListPluginsResponse) ProtoMessage()

func (*ListPluginsResponse) ProtoReflect 

func (x *ListPluginsResponse) ProtoReflect() protoreflect.Message

func (*ListPluginsResponse) Reset 

func (x *ListPluginsResponse) Reset()

func (*ListPluginsResponse) String 

func (x *ListPluginsResponse) String() string

type ListRoutesRequest 

type ListRoutesRequest struct {
	Cluster   *v1.RequestCluster    `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	ServiceId string                `protobuf:"bytes,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"`
	Page      *v1.PaginationRequest `protobuf:"bytes,3,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListRoutesRequest) Descriptor deprecated 

func (*ListRoutesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListRoutesRequest.ProtoReflect.Descriptor instead.

func (*ListRoutesRequest) GetCluster 

func (x *ListRoutesRequest) GetCluster() *v1.RequestCluster

func (*ListRoutesRequest) GetPage 

func (x *ListRoutesRequest) GetPage() *v1.PaginationRequest

func (*ListRoutesRequest) GetServiceId 

func (x *ListRoutesRequest) GetServiceId() string

func (*ListRoutesRequest) ProtoMessage 

func (*ListRoutesRequest) ProtoMessage()

func (*ListRoutesRequest) ProtoReflect 

func (x *ListRoutesRequest) ProtoReflect() protoreflect.Message

func (*ListRoutesRequest) Reset 

func (x *ListRoutesRequest) Reset()

func (*ListRoutesRequest) String 

func (x *ListRoutesRequest) String() string

type ListRoutesResponse 

type ListRoutesResponse struct {
	Items []*v1.Route            `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Page  *v1.PaginationResponse `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListRoutesResponse) Descriptor deprecated 

func (*ListRoutesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListRoutesResponse.ProtoReflect.Descriptor instead.

func (*ListRoutesResponse) GetItems 

func (x *ListRoutesResponse) GetItems() []*v1.Route

func (*ListRoutesResponse) GetPage 

func (x *ListRoutesResponse) GetPage() *v1.PaginationResponse

func (*ListRoutesResponse) ProtoMessage 

func (*ListRoutesResponse) ProtoMessage()

func (*ListRoutesResponse) ProtoReflect 

func (x *ListRoutesResponse) ProtoReflect() protoreflect.Message

func (*ListRoutesResponse) Reset 

func (x *ListRoutesResponse) Reset()

func (*ListRoutesResponse) String 

func (x *ListRoutesResponse) String() string

type ListSNIsRequest 

type ListSNIsRequest struct {
	Cluster       *v1.RequestCluster    `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Page          *v1.PaginationRequest `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	CertificateId string                `protobuf:"bytes,3,opt,name=certificate_id,json=certificateId,proto3" json:"certificate_id,omitempty"`
	// contains filtered or unexported fields
}

func (*ListSNIsRequest) Descriptor deprecated 

func (*ListSNIsRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListSNIsRequest.ProtoReflect.Descriptor instead.

func (*ListSNIsRequest) GetCertificateId 

func (x *ListSNIsRequest) GetCertificateId() string

func (*ListSNIsRequest) GetCluster 

func (x *ListSNIsRequest) GetCluster() *v1.RequestCluster

func (*ListSNIsRequest) GetPage 

func (x *ListSNIsRequest) GetPage() *v1.PaginationRequest

func (*ListSNIsRequest) ProtoMessage 

func (*ListSNIsRequest) ProtoMessage()

func (*ListSNIsRequest) ProtoReflect 

func (x *ListSNIsRequest) ProtoReflect() protoreflect.Message

func (*ListSNIsRequest) Reset 

func (x *ListSNIsRequest) Reset()

func (*ListSNIsRequest) String 

func (x *ListSNIsRequest) String() string

type ListSNIsResponse 

type ListSNIsResponse struct {
	Items []*v1.SNI              `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Page  *v1.PaginationResponse `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListSNIsResponse) Descriptor deprecated 

func (*ListSNIsResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListSNIsResponse.ProtoReflect.Descriptor instead.

func (*ListSNIsResponse) GetItems 

func (x *ListSNIsResponse) GetItems() []*v1.SNI

func (*ListSNIsResponse) GetPage 

func (x *ListSNIsResponse) GetPage() *v1.PaginationResponse

func (*ListSNIsResponse) ProtoMessage 

func (*ListSNIsResponse) ProtoMessage()

func (*ListSNIsResponse) ProtoReflect 

func (x *ListSNIsResponse) ProtoReflect() protoreflect.Message

func (*ListSNIsResponse) Reset 

func (x *ListSNIsResponse) Reset()

func (*ListSNIsResponse) String 

func (x *ListSNIsResponse) String() string

type ListServicesRequest 

type ListServicesRequest struct {
	Cluster *v1.RequestCluster    `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Page    *v1.PaginationRequest `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListServicesRequest) Descriptor deprecated 

func (*ListServicesRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListServicesRequest.ProtoReflect.Descriptor instead.

func (*ListServicesRequest) GetCluster 

func (x *ListServicesRequest) GetCluster() *v1.RequestCluster

func (*ListServicesRequest) GetPage 

func (x *ListServicesRequest) GetPage() *v1.PaginationRequest

func (*ListServicesRequest) ProtoMessage 

func (*ListServicesRequest) ProtoMessage()

func (*ListServicesRequest) ProtoReflect 

func (x *ListServicesRequest) ProtoReflect() protoreflect.Message

func (*ListServicesRequest) Reset 

func (x *ListServicesRequest) Reset()

func (*ListServicesRequest) String 

func (x *ListServicesRequest) String() string

type ListServicesResponse 

type ListServicesResponse struct {
	Items []*v1.Service          `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Page  *v1.PaginationResponse `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListServicesResponse) Descriptor deprecated 

func (*ListServicesResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListServicesResponse.ProtoReflect.Descriptor instead.

func (*ListServicesResponse) GetItems 

func (x *ListServicesResponse) GetItems() []*v1.Service

func (*ListServicesResponse) GetPage 

func (x *ListServicesResponse) GetPage() *v1.PaginationResponse

func (*ListServicesResponse) ProtoMessage 

func (*ListServicesResponse) ProtoMessage()

func (*ListServicesResponse) ProtoReflect 

func (x *ListServicesResponse) ProtoReflect() protoreflect.Message

func (*ListServicesResponse) Reset 

func (x *ListServicesResponse) Reset()

func (*ListServicesResponse) String 

func (x *ListServicesResponse) String() string

type ListTargetsRequest 

type ListTargetsRequest struct {
	UpstreamId string                `protobuf:"bytes,1,opt,name=upstream_id,json=upstreamId,proto3" json:"upstream_id,omitempty"`
	Cluster    *v1.RequestCluster    `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Page       *v1.PaginationRequest `protobuf:"bytes,3,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListTargetsRequest) Descriptor deprecated 

func (*ListTargetsRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListTargetsRequest.ProtoReflect.Descriptor instead.

func (*ListTargetsRequest) GetCluster 

func (x *ListTargetsRequest) GetCluster() *v1.RequestCluster

func (*ListTargetsRequest) GetPage 

func (x *ListTargetsRequest) GetPage() *v1.PaginationRequest

func (*ListTargetsRequest) GetUpstreamId 

func (x *ListTargetsRequest) GetUpstreamId() string

func (*ListTargetsRequest) ProtoMessage 

func (*ListTargetsRequest) ProtoMessage()

func (*ListTargetsRequest) ProtoReflect 

func (x *ListTargetsRequest) ProtoReflect() protoreflect.Message

func (*ListTargetsRequest) Reset 

func (x *ListTargetsRequest) Reset()

func (*ListTargetsRequest) String 

func (x *ListTargetsRequest) String() string

type ListTargetsResponse 

type ListTargetsResponse struct {
	Items []*v1.Target           `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Page  *v1.PaginationResponse `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListTargetsResponse) Descriptor deprecated 

func (*ListTargetsResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListTargetsResponse.ProtoReflect.Descriptor instead.

func (*ListTargetsResponse) GetItems 

func (x *ListTargetsResponse) GetItems() []*v1.Target

func (*ListTargetsResponse) GetPage 

func (x *ListTargetsResponse) GetPage() *v1.PaginationResponse

func (*ListTargetsResponse) ProtoMessage 

func (*ListTargetsResponse) ProtoMessage()

func (*ListTargetsResponse) ProtoReflect 

func (x *ListTargetsResponse) ProtoReflect() protoreflect.Message

func (*ListTargetsResponse) Reset 

func (x *ListTargetsResponse) Reset()

func (*ListTargetsResponse) String 

func (x *ListTargetsResponse) String() string

type ListUpstreamsRequest 

type ListUpstreamsRequest struct {
	Cluster *v1.RequestCluster    `protobuf:"bytes,1,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Page    *v1.PaginationRequest `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListUpstreamsRequest) Descriptor deprecated 

func (*ListUpstreamsRequest) Descriptor() ([]byte, []int)

Deprecated: Use ListUpstreamsRequest.ProtoReflect.Descriptor instead.

func (*ListUpstreamsRequest) GetCluster 

func (x *ListUpstreamsRequest) GetCluster() *v1.RequestCluster

func (*ListUpstreamsRequest) GetPage 

func (x *ListUpstreamsRequest) GetPage() *v1.PaginationRequest

func (*ListUpstreamsRequest) ProtoMessage 

func (*ListUpstreamsRequest) ProtoMessage()

func (*ListUpstreamsRequest) ProtoReflect 

func (x *ListUpstreamsRequest) ProtoReflect() protoreflect.Message

func (*ListUpstreamsRequest) Reset 

func (x *ListUpstreamsRequest) Reset()

func (*ListUpstreamsRequest) String 

func (x *ListUpstreamsRequest) String() string

type ListUpstreamsResponse 

type ListUpstreamsResponse struct {
	Items []*v1.Upstream         `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	Page  *v1.PaginationResponse `protobuf:"bytes,2,opt,name=page,proto3" json:"page,omitempty"`
	// contains filtered or unexported fields
}

func (*ListUpstreamsResponse) Descriptor deprecated 

func (*ListUpstreamsResponse) Descriptor() ([]byte, []int)

Deprecated: Use ListUpstreamsResponse.ProtoReflect.Descriptor instead.

func (*ListUpstreamsResponse) GetItems 

func (x *ListUpstreamsResponse) GetItems() []*v1.Upstream

func (*ListUpstreamsResponse) GetPage 

func (x *ListUpstreamsResponse) GetPage() *v1.PaginationResponse

func (*ListUpstreamsResponse) ProtoMessage 

func (*ListUpstreamsResponse) ProtoMessage()

func (*ListUpstreamsResponse) ProtoReflect 

func (x *ListUpstreamsResponse) ProtoReflect() protoreflect.Message

func (*ListUpstreamsResponse) Reset 

func (x *ListUpstreamsResponse) Reset()

func (*ListUpstreamsResponse) String 

func (x *ListUpstreamsResponse) String() string

type MetaServiceClient 

type MetaServiceClient interface {
	GetVersion(ctx context.Context, in *GetVersionRequest, opts ...grpc.CallOption) (*GetVersionResponse, error)
}

MetaServiceClient is the client API for MetaService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewMetaServiceClient 

func NewMetaServiceClient(cc grpc.ClientConnInterface) MetaServiceClient

type MetaServiceServer 

type MetaServiceServer interface {
	GetVersion(context.Context, *GetVersionRequest) (*GetVersionResponse, error)
	// contains filtered or unexported methods
}

MetaServiceServer is the server API for MetaService service. All implementations must embed UnimplementedMetaServiceServer for forward compatibility

type NodeServiceClient 

type NodeServiceClient interface {
	GetNode(ctx context.Context, in *GetNodeRequest, opts ...grpc.CallOption) (*GetNodeResponse, error)
	CreateNode(ctx context.Context, in *CreateNodeRequest, opts ...grpc.CallOption) (*CreateNodeResponse, error)
	UpsertNode(ctx context.Context, in *UpsertNodeRequest, opts ...grpc.CallOption) (*UpsertNodeResponse, error)
	DeleteNode(ctx context.Context, in *DeleteNodeRequest, opts ...grpc.CallOption) (*DeleteNodeResponse, error)
	ListNodes(ctx context.Context, in *ListNodesRequest, opts ...grpc.CallOption) (*ListNodesResponse, error)
}

NodeServiceClient is the client API for NodeService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewNodeServiceClient 

func NewNodeServiceClient(cc grpc.ClientConnInterface) NodeServiceClient

type NodeServiceServer 

type NodeServiceServer interface {
	GetNode(context.Context, *GetNodeRequest) (*GetNodeResponse, error)
	CreateNode(context.Context, *CreateNodeRequest) (*CreateNodeResponse, error)
	UpsertNode(context.Context, *UpsertNodeRequest) (*UpsertNodeResponse, error)
	DeleteNode(context.Context, *DeleteNodeRequest) (*DeleteNodeResponse, error)
	ListNodes(context.Context, *ListNodesRequest) (*ListNodesResponse, error)
	// contains filtered or unexported methods
}

NodeServiceServer is the server API for NodeService service. All implementations must embed UnimplementedNodeServiceServer for forward compatibility

type PluginSchemaServiceClient 

type PluginSchemaServiceClient interface {
	CreateLuaPluginSchema(ctx context.Context, in *CreateLuaPluginSchemaRequest, opts ...grpc.CallOption) (*CreateLuaPluginSchemaResponse, error)
	GetLuaPluginSchema(ctx context.Context, in *GetLuaPluginSchemaRequest, opts ...grpc.CallOption) (*GetLuaPluginSchemaResponse, error)
	ListLuaPluginSchemas(ctx context.Context, in *ListLuaPluginSchemasRequest, opts ...grpc.CallOption) (*ListLuaPluginSchemasResponse, error)
	UpsertLuaPluginSchema(ctx context.Context, in *UpsertLuaPluginSchemaRequest, opts ...grpc.CallOption) (*UpsertLuaPluginSchemaResponse, error)
	DeleteLuaPluginSchema(ctx context.Context, in *DeleteLuaPluginSchemaRequest, opts ...grpc.CallOption) (*DeleteLuaPluginSchemaResponse, error)
}

PluginSchemaServiceClient is the client API for PluginSchemaService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewPluginSchemaServiceClient 

func NewPluginSchemaServiceClient(cc grpc.ClientConnInterface) PluginSchemaServiceClient

type PluginSchemaServiceServer 

type PluginSchemaServiceServer interface {
	CreateLuaPluginSchema(context.Context, *CreateLuaPluginSchemaRequest) (*CreateLuaPluginSchemaResponse, error)
	GetLuaPluginSchema(context.Context, *GetLuaPluginSchemaRequest) (*GetLuaPluginSchemaResponse, error)
	ListLuaPluginSchemas(context.Context, *ListLuaPluginSchemasRequest) (*ListLuaPluginSchemasResponse, error)
	UpsertLuaPluginSchema(context.Context, *UpsertLuaPluginSchemaRequest) (*UpsertLuaPluginSchemaResponse, error)
	DeleteLuaPluginSchema(context.Context, *DeleteLuaPluginSchemaRequest) (*DeleteLuaPluginSchemaResponse, error)
	// contains filtered or unexported methods
}

PluginSchemaServiceServer is the server API for PluginSchemaService service. All implementations must embed UnimplementedPluginSchemaServiceServer for forward compatibility

type PluginServiceClient 

type PluginServiceClient interface {
	GetConfiguredPlugins(ctx context.Context, in *GetConfiguredPluginsRequest, opts ...grpc.CallOption) (*GetConfiguredPluginsResponse, error)
	GetAvailablePlugins(ctx context.Context, in *GetAvailablePluginsRequest, opts ...grpc.CallOption) (*GetAvailablePluginsResponse, error)
	GetPlugin(ctx context.Context, in *GetPluginRequest, opts ...grpc.CallOption) (*GetPluginResponse, error)
	CreatePlugin(ctx context.Context, in *CreatePluginRequest, opts ...grpc.CallOption) (*CreatePluginResponse, error)
	UpsertPlugin(ctx context.Context, in *UpsertPluginRequest, opts ...grpc.CallOption) (*UpsertPluginResponse, error)
	DeletePlugin(ctx context.Context, in *DeletePluginRequest, opts ...grpc.CallOption) (*DeletePluginResponse, error)
	ListPlugins(ctx context.Context, in *ListPluginsRequest, opts ...grpc.CallOption) (*ListPluginsResponse, error)
}

PluginServiceClient is the client API for PluginService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewPluginServiceClient 

func NewPluginServiceClient(cc grpc.ClientConnInterface) PluginServiceClient

type PluginServiceServer 

type PluginServiceServer interface {
	GetConfiguredPlugins(context.Context, *GetConfiguredPluginsRequest) (*GetConfiguredPluginsResponse, error)
	GetAvailablePlugins(context.Context, *GetAvailablePluginsRequest) (*GetAvailablePluginsResponse, error)
	GetPlugin(context.Context, *GetPluginRequest) (*GetPluginResponse, error)
	CreatePlugin(context.Context, *CreatePluginRequest) (*CreatePluginResponse, error)
	UpsertPlugin(context.Context, *UpsertPluginRequest) (*UpsertPluginResponse, error)
	DeletePlugin(context.Context, *DeletePluginRequest) (*DeletePluginResponse, error)
	ListPlugins(context.Context, *ListPluginsRequest) (*ListPluginsResponse, error)
	// contains filtered or unexported methods
}

PluginServiceServer is the server API for PluginService service. All implementations must embed UnimplementedPluginServiceServer for forward compatibility

type RouteServiceClient 

type RouteServiceClient interface {
	GetRoute(ctx context.Context, in *GetRouteRequest, opts ...grpc.CallOption) (*GetRouteResponse, error)
	CreateRoute(ctx context.Context, in *CreateRouteRequest, opts ...grpc.CallOption) (*CreateRouteResponse, error)
	UpsertRoute(ctx context.Context, in *UpsertRouteRequest, opts ...grpc.CallOption) (*UpsertRouteResponse, error)
	DeleteRoute(ctx context.Context, in *DeleteRouteRequest, opts ...grpc.CallOption) (*DeleteRouteResponse, error)
	ListRoutes(ctx context.Context, in *ListRoutesRequest, opts ...grpc.CallOption) (*ListRoutesResponse, error)
}

RouteServiceClient is the client API for RouteService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewRouteServiceClient 

func NewRouteServiceClient(cc grpc.ClientConnInterface) RouteServiceClient

type RouteServiceServer 

type RouteServiceServer interface {
	GetRoute(context.Context, *GetRouteRequest) (*GetRouteResponse, error)
	CreateRoute(context.Context, *CreateRouteRequest) (*CreateRouteResponse, error)
	UpsertRoute(context.Context, *UpsertRouteRequest) (*UpsertRouteResponse, error)
	DeleteRoute(context.Context, *DeleteRouteRequest) (*DeleteRouteResponse, error)
	ListRoutes(context.Context, *ListRoutesRequest) (*ListRoutesResponse, error)
	// contains filtered or unexported methods
}

RouteServiceServer is the server API for RouteService service. All implementations must embed UnimplementedRouteServiceServer for forward compatibility

type SNIServiceClient 

type SNIServiceClient interface {
	GetSNI(ctx context.Context, in *GetSNIRequest, opts ...grpc.CallOption) (*GetSNIResponse, error)
	CreateSNI(ctx context.Context, in *CreateSNIRequest, opts ...grpc.CallOption) (*CreateSNIResponse, error)
	UpsertSNI(ctx context.Context, in *UpsertSNIRequest, opts ...grpc.CallOption) (*UpsertSNIResponse, error)
	DeleteSNI(ctx context.Context, in *DeleteSNIRequest, opts ...grpc.CallOption) (*DeleteSNIResponse, error)
	ListSNIs(ctx context.Context, in *ListSNIsRequest, opts ...grpc.CallOption) (*ListSNIsResponse, error)
}

SNIServiceClient is the client API for SNIService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewSNIServiceClient 

func NewSNIServiceClient(cc grpc.ClientConnInterface) SNIServiceClient

type SNIServiceServer 

type SNIServiceServer interface {
	GetSNI(context.Context, *GetSNIRequest) (*GetSNIResponse, error)
	CreateSNI(context.Context, *CreateSNIRequest) (*CreateSNIResponse, error)
	UpsertSNI(context.Context, *UpsertSNIRequest) (*UpsertSNIResponse, error)
	DeleteSNI(context.Context, *DeleteSNIRequest) (*DeleteSNIResponse, error)
	ListSNIs(context.Context, *ListSNIsRequest) (*ListSNIsResponse, error)
	// contains filtered or unexported methods
}

SNIServiceServer is the server API for SNIService service. All implementations must embed UnimplementedSNIServiceServer for forward compatibility

type SchemasServiceClient 

type SchemasServiceClient interface {
	ValidateLuaPlugin(ctx context.Context, in *ValidateLuaPluginRequest, opts ...grpc.CallOption) (*ValidateLuaPluginResponse, error)
	ValidateCACertificateSchema(ctx context.Context, in *ValidateCACertificateSchemaRequest, opts ...grpc.CallOption) (*ValidateCACertificateSchemaResponse, error)
	ValidateCertificateSchema(ctx context.Context, in *ValidateCertificateSchemaRequest, opts ...grpc.CallOption) (*ValidateCertificateSchemaResponse, error)
	ValidateConsumerSchema(ctx context.Context, in *ValidateConsumerSchemaRequest, opts ...grpc.CallOption) (*ValidateConsumerSchemaResponse, error)
	ValidatePluginSchema(ctx context.Context, in *ValidatePluginSchemaRequest, opts ...grpc.CallOption) (*ValidatePluginSchemaResponse, error)
	ValidateRouteSchema(ctx context.Context, in *ValidateRouteSchemaRequest, opts ...grpc.CallOption) (*ValidateRouteSchemaResponse, error)
	ValidateServiceSchema(ctx context.Context, in *ValidateServiceSchemaRequest, opts ...grpc.CallOption) (*ValidateServiceSchemaResponse, error)
	ValidateSNISchema(ctx context.Context, in *ValidateSNISchemaRequest, opts ...grpc.CallOption) (*ValidateSNISchemaResponse, error)
	ValidateTargetSchema(ctx context.Context, in *ValidateTargetSchemaRequest, opts ...grpc.CallOption) (*ValidateTargetSchemaResponse, error)
	ValidateUpstreamSchema(ctx context.Context, in *ValidateUpstreamSchemaRequest, opts ...grpc.CallOption) (*ValidateUpstreamSchemaResponse, error)
	GetSchemas(ctx context.Context, in *GetSchemasRequest, opts ...grpc.CallOption) (*GetSchemasResponse, error)
	GetLuaSchemasPlugin(ctx context.Context, in *GetLuaSchemasPluginRequest, opts ...grpc.CallOption) (*GetLuaSchemasPluginResponse, error)
}

SchemasServiceClient is the client API for SchemasService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewSchemasServiceClient 

func NewSchemasServiceClient(cc grpc.ClientConnInterface) SchemasServiceClient

type SchemasServiceServer 

type SchemasServiceServer interface {
	ValidateLuaPlugin(context.Context, *ValidateLuaPluginRequest) (*ValidateLuaPluginResponse, error)
	ValidateCACertificateSchema(context.Context, *ValidateCACertificateSchemaRequest) (*ValidateCACertificateSchemaResponse, error)
	ValidateCertificateSchema(context.Context, *ValidateCertificateSchemaRequest) (*ValidateCertificateSchemaResponse, error)
	ValidateConsumerSchema(context.Context, *ValidateConsumerSchemaRequest) (*ValidateConsumerSchemaResponse, error)
	ValidatePluginSchema(context.Context, *ValidatePluginSchemaRequest) (*ValidatePluginSchemaResponse, error)
	ValidateRouteSchema(context.Context, *ValidateRouteSchemaRequest) (*ValidateRouteSchemaResponse, error)
	ValidateServiceSchema(context.Context, *ValidateServiceSchemaRequest) (*ValidateServiceSchemaResponse, error)
	ValidateSNISchema(context.Context, *ValidateSNISchemaRequest) (*ValidateSNISchemaResponse, error)
	ValidateTargetSchema(context.Context, *ValidateTargetSchemaRequest) (*ValidateTargetSchemaResponse, error)
	ValidateUpstreamSchema(context.Context, *ValidateUpstreamSchemaRequest) (*ValidateUpstreamSchemaResponse, error)
	GetSchemas(context.Context, *GetSchemasRequest) (*GetSchemasResponse, error)
	GetLuaSchemasPlugin(context.Context, *GetLuaSchemasPluginRequest) (*GetLuaSchemasPluginResponse, error)
	// contains filtered or unexported methods
}

SchemasServiceServer is the server API for SchemasService service. All implementations must embed UnimplementedSchemasServiceServer for forward compatibility

type ServiceServiceClient 

type ServiceServiceClient interface {
	GetService(ctx context.Context, in *GetServiceRequest, opts ...grpc.CallOption) (*GetServiceResponse, error)
	CreateService(ctx context.Context, in *CreateServiceRequest, opts ...grpc.CallOption) (*CreateServiceResponse, error)
	UpsertService(ctx context.Context, in *UpsertServiceRequest, opts ...grpc.CallOption) (*UpsertServiceResponse, error)
	DeleteService(ctx context.Context, in *DeleteServiceRequest, opts ...grpc.CallOption) (*DeleteServiceResponse, error)
	ListServices(ctx context.Context, in *ListServicesRequest, opts ...grpc.CallOption) (*ListServicesResponse, error)
}

ServiceServiceClient is the client API for ServiceService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewServiceServiceClient 

func NewServiceServiceClient(cc grpc.ClientConnInterface) ServiceServiceClient

type ServiceServiceServer 

type ServiceServiceServer interface {
	GetService(context.Context, *GetServiceRequest) (*GetServiceResponse, error)
	CreateService(context.Context, *CreateServiceRequest) (*CreateServiceResponse, error)
	UpsertService(context.Context, *UpsertServiceRequest) (*UpsertServiceResponse, error)
	DeleteService(context.Context, *DeleteServiceRequest) (*DeleteServiceResponse, error)
	ListServices(context.Context, *ListServicesRequest) (*ListServicesResponse, error)
	// contains filtered or unexported methods
}

ServiceServiceServer is the server API for ServiceService service. All implementations must embed UnimplementedServiceServiceServer for forward compatibility

type StatusServiceClient 

type StatusServiceClient interface {
	GetHash(ctx context.Context, in *GetHashRequest, opts ...grpc.CallOption) (*GetHashResponse, error)
}

StatusServiceClient is the client API for StatusService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewStatusServiceClient 

func NewStatusServiceClient(cc grpc.ClientConnInterface) StatusServiceClient

type StatusServiceServer 

type StatusServiceServer interface {
	GetHash(context.Context, *GetHashRequest) (*GetHashResponse, error)
	// contains filtered or unexported methods
}

StatusServiceServer is the server API for StatusService service. All implementations must embed UnimplementedStatusServiceServer for forward compatibility

type TargetServiceClient 

type TargetServiceClient interface {
	GetTarget(ctx context.Context, in *GetTargetRequest, opts ...grpc.CallOption) (*GetTargetResponse, error)
	CreateTarget(ctx context.Context, in *CreateTargetRequest, opts ...grpc.CallOption) (*CreateTargetResponse, error)
	UpsertTarget(ctx context.Context, in *UpsertTargetRequest, opts ...grpc.CallOption) (*UpsertTargetResponse, error)
	DeleteTarget(ctx context.Context, in *DeleteTargetRequest, opts ...grpc.CallOption) (*DeleteTargetResponse, error)
	ListTargets(ctx context.Context, in *ListTargetsRequest, opts ...grpc.CallOption) (*ListTargetsResponse, error)
}

TargetServiceClient is the client API for TargetService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewTargetServiceClient 

func NewTargetServiceClient(cc grpc.ClientConnInterface) TargetServiceClient

type TargetServiceServer 

type TargetServiceServer interface {
	GetTarget(context.Context, *GetTargetRequest) (*GetTargetResponse, error)
	CreateTarget(context.Context, *CreateTargetRequest) (*CreateTargetResponse, error)
	UpsertTarget(context.Context, *UpsertTargetRequest) (*UpsertTargetResponse, error)
	DeleteTarget(context.Context, *DeleteTargetRequest) (*DeleteTargetResponse, error)
	ListTargets(context.Context, *ListTargetsRequest) (*ListTargetsResponse, error)
	// contains filtered or unexported methods
}

TargetServiceServer is the server API for TargetService service. All implementations must embed UnimplementedTargetServiceServer for forward compatibility

type UnimplementedCACertificateServiceServer 

type UnimplementedCACertificateServiceServer struct {
}

UnimplementedCACertificateServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedCACertificateServiceServer) CreateCACertificate 

func (UnimplementedCACertificateServiceServer) CreateCACertificate(context.Context, *CreateCACertificateRequest) (*CreateCACertificateResponse, error)

func (UnimplementedCACertificateServiceServer) DeleteCACertificate 

func (UnimplementedCACertificateServiceServer) DeleteCACertificate(context.Context, *DeleteCACertificateRequest) (*DeleteCACertificateResponse, error)

func (UnimplementedCACertificateServiceServer) GetCACertificate 

func (UnimplementedCACertificateServiceServer) GetCACertificate(context.Context, *GetCACertificateRequest) (*GetCACertificateResponse, error)

func (UnimplementedCACertificateServiceServer) ListCACertificates 

func (UnimplementedCACertificateServiceServer) ListCACertificates(context.Context, *ListCACertificatesRequest) (*ListCACertificatesResponse, error)

func (UnimplementedCACertificateServiceServer) UpsertCACertificate 

func (UnimplementedCACertificateServiceServer) UpsertCACertificate(context.Context, *UpsertCACertificateRequest) (*UpsertCACertificateResponse, error)

type UnimplementedCertificateServiceServer 

type UnimplementedCertificateServiceServer struct {
}

UnimplementedCertificateServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedCertificateServiceServer) CreateCertificate 

func (UnimplementedCertificateServiceServer) CreateCertificate(context.Context, *CreateCertificateRequest) (*CreateCertificateResponse, error)

func (UnimplementedCertificateServiceServer) DeleteCertificate 

func (UnimplementedCertificateServiceServer) DeleteCertificate(context.Context, *DeleteCertificateRequest) (*DeleteCertificateResponse, error)

func (UnimplementedCertificateServiceServer) GetCertificate 

func (UnimplementedCertificateServiceServer) GetCertificate(context.Context, *GetCertificateRequest) (*GetCertificateResponse, error)

func (UnimplementedCertificateServiceServer) ListCertificates 

func (UnimplementedCertificateServiceServer) ListCertificates(context.Context, *ListCertificatesRequest) (*ListCertificatesResponse, error)

func (UnimplementedCertificateServiceServer) UpsertCertificate 

func (UnimplementedCertificateServiceServer) UpsertCertificate(context.Context, *UpsertCertificateRequest) (*UpsertCertificateResponse, error)

type UnimplementedConsumerServiceServer 

type UnimplementedConsumerServiceServer struct {
}

UnimplementedConsumerServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedConsumerServiceServer) CreateConsumer 

func (UnimplementedConsumerServiceServer) CreateConsumer(context.Context, *CreateConsumerRequest) (*CreateConsumerResponse, error)

func (UnimplementedConsumerServiceServer) DeleteConsumer 

func (UnimplementedConsumerServiceServer) DeleteConsumer(context.Context, *DeleteConsumerRequest) (*DeleteConsumerResponse, error)

func (UnimplementedConsumerServiceServer) GetConsumer 

func (UnimplementedConsumerServiceServer) GetConsumer(context.Context, *GetConsumerRequest) (*GetConsumerResponse, error)

func (UnimplementedConsumerServiceServer) ListConsumers 

func (UnimplementedConsumerServiceServer) ListConsumers(context.Context, *ListConsumersRequest) (*ListConsumersResponse, error)

func (UnimplementedConsumerServiceServer) UpsertConsumer 

func (UnimplementedConsumerServiceServer) UpsertConsumer(context.Context, *UpsertConsumerRequest) (*UpsertConsumerResponse, error)

type UnimplementedMetaServiceServer 

type UnimplementedMetaServiceServer struct {
}

UnimplementedMetaServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedMetaServiceServer) GetVersion 

func (UnimplementedMetaServiceServer) GetVersion(context.Context, *GetVersionRequest) (*GetVersionResponse, error)

type UnimplementedNodeServiceServer 

type UnimplementedNodeServiceServer struct {
}

UnimplementedNodeServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedNodeServiceServer) CreateNode 

func (UnimplementedNodeServiceServer) CreateNode(context.Context, *CreateNodeRequest) (*CreateNodeResponse, error)

func (UnimplementedNodeServiceServer) DeleteNode 

func (UnimplementedNodeServiceServer) DeleteNode(context.Context, *DeleteNodeRequest) (*DeleteNodeResponse, error)

func (UnimplementedNodeServiceServer) GetNode 

func (UnimplementedNodeServiceServer) GetNode(context.Context, *GetNodeRequest) (*GetNodeResponse, error)

func (UnimplementedNodeServiceServer) ListNodes 

func (UnimplementedNodeServiceServer) ListNodes(context.Context, *ListNodesRequest) (*ListNodesResponse, error)

func (UnimplementedNodeServiceServer) UpsertNode 

func (UnimplementedNodeServiceServer) UpsertNode(context.Context, *UpsertNodeRequest) (*UpsertNodeResponse, error)

type UnimplementedPluginSchemaServiceServer 

type UnimplementedPluginSchemaServiceServer struct {
}

UnimplementedPluginSchemaServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedPluginSchemaServiceServer) CreateLuaPluginSchema 

func (UnimplementedPluginSchemaServiceServer) CreateLuaPluginSchema(context.Context, *CreateLuaPluginSchemaRequest) (*CreateLuaPluginSchemaResponse, error)

func (UnimplementedPluginSchemaServiceServer) DeleteLuaPluginSchema 

func (UnimplementedPluginSchemaServiceServer) DeleteLuaPluginSchema(context.Context, *DeleteLuaPluginSchemaRequest) (*DeleteLuaPluginSchemaResponse, error)

func (UnimplementedPluginSchemaServiceServer) GetLuaPluginSchema 

func (UnimplementedPluginSchemaServiceServer) GetLuaPluginSchema(context.Context, *GetLuaPluginSchemaRequest) (*GetLuaPluginSchemaResponse, error)

func (UnimplementedPluginSchemaServiceServer) ListLuaPluginSchemas 

func (UnimplementedPluginSchemaServiceServer) ListLuaPluginSchemas(context.Context, *ListLuaPluginSchemasRequest) (*ListLuaPluginSchemasResponse, error)

func (UnimplementedPluginSchemaServiceServer) UpsertLuaPluginSchema 

func (UnimplementedPluginSchemaServiceServer) UpsertLuaPluginSchema(context.Context, *UpsertLuaPluginSchemaRequest) (*UpsertLuaPluginSchemaResponse, error)

type UnimplementedPluginServiceServer 

type UnimplementedPluginServiceServer struct {
}

UnimplementedPluginServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedPluginServiceServer) CreatePlugin 

func (UnimplementedPluginServiceServer) CreatePlugin(context.Context, *CreatePluginRequest) (*CreatePluginResponse, error)

func (UnimplementedPluginServiceServer) DeletePlugin 

func (UnimplementedPluginServiceServer) DeletePlugin(context.Context, *DeletePluginRequest) (*DeletePluginResponse, error)

func (UnimplementedPluginServiceServer) GetAvailablePlugins 

func (UnimplementedPluginServiceServer) GetAvailablePlugins(context.Context, *GetAvailablePluginsRequest) (*GetAvailablePluginsResponse, error)

func (UnimplementedPluginServiceServer) GetConfiguredPlugins 

func (UnimplementedPluginServiceServer) GetConfiguredPlugins(context.Context, *GetConfiguredPluginsRequest) (*GetConfiguredPluginsResponse, error)

func (UnimplementedPluginServiceServer) GetPlugin 

func (UnimplementedPluginServiceServer) GetPlugin(context.Context, *GetPluginRequest) (*GetPluginResponse, error)

func (UnimplementedPluginServiceServer) ListPlugins 

func (UnimplementedPluginServiceServer) ListPlugins(context.Context, *ListPluginsRequest) (*ListPluginsResponse, error)

func (UnimplementedPluginServiceServer) UpsertPlugin 

func (UnimplementedPluginServiceServer) UpsertPlugin(context.Context, *UpsertPluginRequest) (*UpsertPluginResponse, error)

type UnimplementedRouteServiceServer 

type UnimplementedRouteServiceServer struct {
}

UnimplementedRouteServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedRouteServiceServer) CreateRoute 

func (UnimplementedRouteServiceServer) CreateRoute(context.Context, *CreateRouteRequest) (*CreateRouteResponse, error)

func (UnimplementedRouteServiceServer) DeleteRoute 

func (UnimplementedRouteServiceServer) DeleteRoute(context.Context, *DeleteRouteRequest) (*DeleteRouteResponse, error)

func (UnimplementedRouteServiceServer) GetRoute 

func (UnimplementedRouteServiceServer) GetRoute(context.Context, *GetRouteRequest) (*GetRouteResponse, error)

func (UnimplementedRouteServiceServer) ListRoutes 

func (UnimplementedRouteServiceServer) ListRoutes(context.Context, *ListRoutesRequest) (*ListRoutesResponse, error)

func (UnimplementedRouteServiceServer) UpsertRoute 

func (UnimplementedRouteServiceServer) UpsertRoute(context.Context, *UpsertRouteRequest) (*UpsertRouteResponse, error)

type UnimplementedSNIServiceServer 

type UnimplementedSNIServiceServer struct {
}

UnimplementedSNIServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedSNIServiceServer) CreateSNI 

func (UnimplementedSNIServiceServer) CreateSNI(context.Context, *CreateSNIRequest) (*CreateSNIResponse, error)

func (UnimplementedSNIServiceServer) DeleteSNI 

func (UnimplementedSNIServiceServer) DeleteSNI(context.Context, *DeleteSNIRequest) (*DeleteSNIResponse, error)

func (UnimplementedSNIServiceServer) GetSNI 

func (UnimplementedSNIServiceServer) GetSNI(context.Context, *GetSNIRequest) (*GetSNIResponse, error)

func (UnimplementedSNIServiceServer) ListSNIs 

func (UnimplementedSNIServiceServer) ListSNIs(context.Context, *ListSNIsRequest) (*ListSNIsResponse, error)

func (UnimplementedSNIServiceServer) UpsertSNI 

func (UnimplementedSNIServiceServer) UpsertSNI(context.Context, *UpsertSNIRequest) (*UpsertSNIResponse, error)

type UnimplementedSchemasServiceServer 

type UnimplementedSchemasServiceServer struct {
}

UnimplementedSchemasServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedSchemasServiceServer) GetLuaSchemasPlugin 

func (UnimplementedSchemasServiceServer) GetLuaSchemasPlugin(context.Context, *GetLuaSchemasPluginRequest) (*GetLuaSchemasPluginResponse, error)

func (UnimplementedSchemasServiceServer) GetSchemas 

func (UnimplementedSchemasServiceServer) GetSchemas(context.Context, *GetSchemasRequest) (*GetSchemasResponse, error)

func (UnimplementedSchemasServiceServer) ValidateCACertificateSchema 

func (UnimplementedSchemasServiceServer) ValidateCACertificateSchema(context.Context, *ValidateCACertificateSchemaRequest) (*ValidateCACertificateSchemaResponse, error)

func (UnimplementedSchemasServiceServer) ValidateCertificateSchema 

func (UnimplementedSchemasServiceServer) ValidateCertificateSchema(context.Context, *ValidateCertificateSchemaRequest) (*ValidateCertificateSchemaResponse, error)

func (UnimplementedSchemasServiceServer) ValidateConsumerSchema 

func (UnimplementedSchemasServiceServer) ValidateConsumerSchema(context.Context, *ValidateConsumerSchemaRequest) (*ValidateConsumerSchemaResponse, error)

func (UnimplementedSchemasServiceServer) ValidateLuaPlugin 

func (UnimplementedSchemasServiceServer) ValidateLuaPlugin(context.Context, *ValidateLuaPluginRequest) (*ValidateLuaPluginResponse, error)

func (UnimplementedSchemasServiceServer) ValidatePluginSchema 

func (UnimplementedSchemasServiceServer) ValidatePluginSchema(context.Context, *ValidatePluginSchemaRequest) (*ValidatePluginSchemaResponse, error)

func (UnimplementedSchemasServiceServer) ValidateRouteSchema 

func (UnimplementedSchemasServiceServer) ValidateRouteSchema(context.Context, *ValidateRouteSchemaRequest) (*ValidateRouteSchemaResponse, error)

func (UnimplementedSchemasServiceServer) ValidateSNISchema 

func (UnimplementedSchemasServiceServer) ValidateSNISchema(context.Context, *ValidateSNISchemaRequest) (*ValidateSNISchemaResponse, error)

func (UnimplementedSchemasServiceServer) ValidateServiceSchema 

func (UnimplementedSchemasServiceServer) ValidateServiceSchema(context.Context, *ValidateServiceSchemaRequest) (*ValidateServiceSchemaResponse, error)

func (UnimplementedSchemasServiceServer) ValidateTargetSchema 

func (UnimplementedSchemasServiceServer) ValidateTargetSchema(context.Context, *ValidateTargetSchemaRequest) (*ValidateTargetSchemaResponse, error)

func (UnimplementedSchemasServiceServer) ValidateUpstreamSchema 

func (UnimplementedSchemasServiceServer) ValidateUpstreamSchema(context.Context, *ValidateUpstreamSchemaRequest) (*ValidateUpstreamSchemaResponse, error)

type UnimplementedServiceServiceServer 

type UnimplementedServiceServiceServer struct {
}

UnimplementedServiceServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedServiceServiceServer) CreateService 

func (UnimplementedServiceServiceServer) CreateService(context.Context, *CreateServiceRequest) (*CreateServiceResponse, error)

func (UnimplementedServiceServiceServer) DeleteService 

func (UnimplementedServiceServiceServer) DeleteService(context.Context, *DeleteServiceRequest) (*DeleteServiceResponse, error)

func (UnimplementedServiceServiceServer) GetService 

func (UnimplementedServiceServiceServer) GetService(context.Context, *GetServiceRequest) (*GetServiceResponse, error)

func (UnimplementedServiceServiceServer) ListServices 

func (UnimplementedServiceServiceServer) ListServices(context.Context, *ListServicesRequest) (*ListServicesResponse, error)

func (UnimplementedServiceServiceServer) UpsertService 

func (UnimplementedServiceServiceServer) UpsertService(context.Context, *UpsertServiceRequest) (*UpsertServiceResponse, error)

type UnimplementedStatusServiceServer 

type UnimplementedStatusServiceServer struct {
}

UnimplementedStatusServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedStatusServiceServer) GetHash 

func (UnimplementedStatusServiceServer) GetHash(context.Context, *GetHashRequest) (*GetHashResponse, error)

type UnimplementedTargetServiceServer 

type UnimplementedTargetServiceServer struct {
}

UnimplementedTargetServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedTargetServiceServer) CreateTarget 

func (UnimplementedTargetServiceServer) CreateTarget(context.Context, *CreateTargetRequest) (*CreateTargetResponse, error)

func (UnimplementedTargetServiceServer) DeleteTarget 

func (UnimplementedTargetServiceServer) DeleteTarget(context.Context, *DeleteTargetRequest) (*DeleteTargetResponse, error)

func (UnimplementedTargetServiceServer) GetTarget 

func (UnimplementedTargetServiceServer) GetTarget(context.Context, *GetTargetRequest) (*GetTargetResponse, error)

func (UnimplementedTargetServiceServer) ListTargets 

func (UnimplementedTargetServiceServer) ListTargets(context.Context, *ListTargetsRequest) (*ListTargetsResponse, error)

func (UnimplementedTargetServiceServer) UpsertTarget 

func (UnimplementedTargetServiceServer) UpsertTarget(context.Context, *UpsertTargetRequest) (*UpsertTargetResponse, error)

type UnimplementedUpstreamServiceServer 

type UnimplementedUpstreamServiceServer struct {
}

UnimplementedUpstreamServiceServer must be embedded to have forward compatible implementations.

func (UnimplementedUpstreamServiceServer) CreateUpstream 

func (UnimplementedUpstreamServiceServer) CreateUpstream(context.Context, *CreateUpstreamRequest) (*CreateUpstreamResponse, error)

func (UnimplementedUpstreamServiceServer) DeleteUpstream 

func (UnimplementedUpstreamServiceServer) DeleteUpstream(context.Context, *DeleteUpstreamRequest) (*DeleteUpstreamResponse, error)

func (UnimplementedUpstreamServiceServer) GetUpstream 

func (UnimplementedUpstreamServiceServer) GetUpstream(context.Context, *GetUpstreamRequest) (*GetUpstreamResponse, error)

func (UnimplementedUpstreamServiceServer) ListUpstreams 

func (UnimplementedUpstreamServiceServer) ListUpstreams(context.Context, *ListUpstreamsRequest) (*ListUpstreamsResponse, error)

func (UnimplementedUpstreamServiceServer) UpsertUpstream 

func (UnimplementedUpstreamServiceServer) UpsertUpstream(context.Context, *UpsertUpstreamRequest) (*UpsertUpstreamResponse, error)

type UnsafeCACertificateServiceServer 

type UnsafeCACertificateServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeCACertificateServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to CACertificateServiceServer will result in compilation errors.

type UnsafeCertificateServiceServer 

type UnsafeCertificateServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeCertificateServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to CertificateServiceServer will result in compilation errors.

type UnsafeConsumerServiceServer 

type UnsafeConsumerServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeConsumerServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ConsumerServiceServer will result in compilation errors.

type UnsafeMetaServiceServer 

type UnsafeMetaServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeMetaServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to MetaServiceServer will result in compilation errors.

type UnsafeNodeServiceServer 

type UnsafeNodeServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeNodeServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to NodeServiceServer will result in compilation errors.

type UnsafePluginSchemaServiceServer 

type UnsafePluginSchemaServiceServer interface {
	// contains filtered or unexported methods
}

UnsafePluginSchemaServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to PluginSchemaServiceServer will result in compilation errors.

type UnsafePluginServiceServer 

type UnsafePluginServiceServer interface {
	// contains filtered or unexported methods
}

UnsafePluginServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to PluginServiceServer will result in compilation errors.

type UnsafeRouteServiceServer 

type UnsafeRouteServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeRouteServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to RouteServiceServer will result in compilation errors.

type UnsafeSNIServiceServer 

type UnsafeSNIServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeSNIServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to SNIServiceServer will result in compilation errors.

type UnsafeSchemasServiceServer 

type UnsafeSchemasServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeSchemasServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to SchemasServiceServer will result in compilation errors.

type UnsafeServiceServiceServer 

type UnsafeServiceServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeServiceServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ServiceServiceServer will result in compilation errors.

type UnsafeStatusServiceServer 

type UnsafeStatusServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeStatusServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to StatusServiceServer will result in compilation errors.

type UnsafeTargetServiceServer 

type UnsafeTargetServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeTargetServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to TargetServiceServer will result in compilation errors.

type UnsafeUpstreamServiceServer 

type UnsafeUpstreamServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeUpstreamServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to UpstreamServiceServer will result in compilation errors.

type UpsertCACertificateRequest 

type UpsertCACertificateRequest struct {
	Item    *v1.CACertificate  `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertCACertificateRequest) Descriptor deprecated 

func (*UpsertCACertificateRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpsertCACertificateRequest.ProtoReflect.Descriptor instead.

func (*UpsertCACertificateRequest) GetCluster 

func (x *UpsertCACertificateRequest) GetCluster() *v1.RequestCluster

func (*UpsertCACertificateRequest) GetItem 

func (x *UpsertCACertificateRequest) GetItem() *v1.CACertificate

func (*UpsertCACertificateRequest) ProtoMessage 

func (*UpsertCACertificateRequest) ProtoMessage()

func (*UpsertCACertificateRequest) ProtoReflect 

func (x *UpsertCACertificateRequest) ProtoReflect() protoreflect.Message

func (*UpsertCACertificateRequest) Reset 

func (x *UpsertCACertificateRequest) Reset()

func (*UpsertCACertificateRequest) String 

func (x *UpsertCACertificateRequest) String() string

type UpsertCACertificateResponse 

type UpsertCACertificateResponse struct {
	Item *v1.CACertificate `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertCACertificateResponse) Descriptor deprecated 

func (*UpsertCACertificateResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpsertCACertificateResponse.ProtoReflect.Descriptor instead.

func (*UpsertCACertificateResponse) GetItem 

func (x *UpsertCACertificateResponse) GetItem() *v1.CACertificate

func (*UpsertCACertificateResponse) ProtoMessage 

func (*UpsertCACertificateResponse) ProtoMessage()

func (*UpsertCACertificateResponse) ProtoReflect 

func (x *UpsertCACertificateResponse) ProtoReflect() protoreflect.Message

func (*UpsertCACertificateResponse) Reset 

func (x *UpsertCACertificateResponse) Reset()

func (*UpsertCACertificateResponse) String 

func (x *UpsertCACertificateResponse) String() string

type UpsertCertificateRequest 

type UpsertCertificateRequest struct {
	Item    *v1.Certificate    `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertCertificateRequest) Descriptor deprecated 

func (*UpsertCertificateRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpsertCertificateRequest.ProtoReflect.Descriptor instead.

func (*UpsertCertificateRequest) GetCluster 

func (x *UpsertCertificateRequest) GetCluster() *v1.RequestCluster

func (*UpsertCertificateRequest) GetItem 

func (x *UpsertCertificateRequest) GetItem() *v1.Certificate

func (*UpsertCertificateRequest) ProtoMessage 

func (*UpsertCertificateRequest) ProtoMessage()

func (*UpsertCertificateRequest) ProtoReflect 

func (x *UpsertCertificateRequest) ProtoReflect() protoreflect.Message

func (*UpsertCertificateRequest) Reset 

func (x *UpsertCertificateRequest) Reset()

func (*UpsertCertificateRequest) String 

func (x *UpsertCertificateRequest) String() string

type UpsertCertificateResponse 

type UpsertCertificateResponse struct {
	Item *v1.Certificate `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertCertificateResponse) Descriptor deprecated 

func (*UpsertCertificateResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpsertCertificateResponse.ProtoReflect.Descriptor instead.

func (*UpsertCertificateResponse) GetItem 

func (x *UpsertCertificateResponse) GetItem() *v1.Certificate

func (*UpsertCertificateResponse) ProtoMessage 

func (*UpsertCertificateResponse) ProtoMessage()

func (*UpsertCertificateResponse) ProtoReflect 

func (x *UpsertCertificateResponse) ProtoReflect() protoreflect.Message

func (*UpsertCertificateResponse) Reset 

func (x *UpsertCertificateResponse) Reset()

func (*UpsertCertificateResponse) String 

func (x *UpsertCertificateResponse) String() string

type UpsertConsumerRequest 

type UpsertConsumerRequest struct {
	Item    *v1.Consumer       `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertConsumerRequest) Descriptor deprecated 

func (*UpsertConsumerRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpsertConsumerRequest.ProtoReflect.Descriptor instead.

func (*UpsertConsumerRequest) GetCluster 

func (x *UpsertConsumerRequest) GetCluster() *v1.RequestCluster

func (*UpsertConsumerRequest) GetItem 

func (x *UpsertConsumerRequest) GetItem() *v1.Consumer

func (*UpsertConsumerRequest) ProtoMessage 

func (*UpsertConsumerRequest) ProtoMessage()

func (*UpsertConsumerRequest) ProtoReflect 

func (x *UpsertConsumerRequest) ProtoReflect() protoreflect.Message

func (*UpsertConsumerRequest) Reset 

func (x *UpsertConsumerRequest) Reset()

func (*UpsertConsumerRequest) String 

func (x *UpsertConsumerRequest) String() string

type UpsertConsumerResponse 

type UpsertConsumerResponse struct {
	Item *v1.Consumer `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertConsumerResponse) Descriptor deprecated 

func (*UpsertConsumerResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpsertConsumerResponse.ProtoReflect.Descriptor instead.

func (*UpsertConsumerResponse) GetItem 

func (x *UpsertConsumerResponse) GetItem() *v1.Consumer

func (*UpsertConsumerResponse) ProtoMessage 

func (*UpsertConsumerResponse) ProtoMessage()

func (*UpsertConsumerResponse) ProtoReflect 

func (x *UpsertConsumerResponse) ProtoReflect() protoreflect.Message

func (*UpsertConsumerResponse) Reset 

func (x *UpsertConsumerResponse) Reset()

func (*UpsertConsumerResponse) String 

func (x *UpsertConsumerResponse) String() string

type UpsertLuaPluginSchemaRequest 

type UpsertLuaPluginSchemaRequest struct {
	Name    string             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Item    *v1.PluginSchema   `protobuf:"bytes,2,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,3,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertLuaPluginSchemaRequest) Descriptor deprecated 

func (*UpsertLuaPluginSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpsertLuaPluginSchemaRequest.ProtoReflect.Descriptor instead.

func (*UpsertLuaPluginSchemaRequest) GetCluster 

func (x *UpsertLuaPluginSchemaRequest) GetCluster() *v1.RequestCluster

func (*UpsertLuaPluginSchemaRequest) GetItem 

func (x *UpsertLuaPluginSchemaRequest) GetItem() *v1.PluginSchema

func (*UpsertLuaPluginSchemaRequest) GetName 

func (x *UpsertLuaPluginSchemaRequest) GetName() string

func (*UpsertLuaPluginSchemaRequest) ProtoMessage 

func (*UpsertLuaPluginSchemaRequest) ProtoMessage()

func (*UpsertLuaPluginSchemaRequest) ProtoReflect 

func (x *UpsertLuaPluginSchemaRequest) ProtoReflect() protoreflect.Message

func (*UpsertLuaPluginSchemaRequest) Reset 

func (x *UpsertLuaPluginSchemaRequest) Reset()

func (*UpsertLuaPluginSchemaRequest) String 

func (x *UpsertLuaPluginSchemaRequest) String() string

type UpsertLuaPluginSchemaResponse 

type UpsertLuaPluginSchemaResponse struct {
	Item *v1.PluginSchema `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertLuaPluginSchemaResponse) Descriptor deprecated 

func (*UpsertLuaPluginSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpsertLuaPluginSchemaResponse.ProtoReflect.Descriptor instead.

func (*UpsertLuaPluginSchemaResponse) GetItem 

func (x *UpsertLuaPluginSchemaResponse) GetItem() *v1.PluginSchema

func (*UpsertLuaPluginSchemaResponse) ProtoMessage 

func (*UpsertLuaPluginSchemaResponse) ProtoMessage()

func (*UpsertLuaPluginSchemaResponse) ProtoReflect 

func (x *UpsertLuaPluginSchemaResponse) ProtoReflect() protoreflect.Message

func (*UpsertLuaPluginSchemaResponse) Reset 

func (x *UpsertLuaPluginSchemaResponse) Reset()

func (*UpsertLuaPluginSchemaResponse) String 

func (x *UpsertLuaPluginSchemaResponse) String() string

type UpsertNodeRequest 

type UpsertNodeRequest struct {
	Item    *v1.Node           `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertNodeRequest) Descriptor deprecated 

func (*UpsertNodeRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpsertNodeRequest.ProtoReflect.Descriptor instead.

func (*UpsertNodeRequest) GetCluster 

func (x *UpsertNodeRequest) GetCluster() *v1.RequestCluster

func (*UpsertNodeRequest) GetItem 

func (x *UpsertNodeRequest) GetItem() *v1.Node

func (*UpsertNodeRequest) ProtoMessage 

func (*UpsertNodeRequest) ProtoMessage()

func (*UpsertNodeRequest) ProtoReflect 

func (x *UpsertNodeRequest) ProtoReflect() protoreflect.Message

func (*UpsertNodeRequest) Reset 

func (x *UpsertNodeRequest) Reset()

func (*UpsertNodeRequest) String 

func (x *UpsertNodeRequest) String() string

type UpsertNodeResponse 

type UpsertNodeResponse struct {
	Item *v1.Node `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertNodeResponse) Descriptor deprecated 

func (*UpsertNodeResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpsertNodeResponse.ProtoReflect.Descriptor instead.

func (*UpsertNodeResponse) GetItem 

func (x *UpsertNodeResponse) GetItem() *v1.Node

func (*UpsertNodeResponse) ProtoMessage 

func (*UpsertNodeResponse) ProtoMessage()

func (*UpsertNodeResponse) ProtoReflect 

func (x *UpsertNodeResponse) ProtoReflect() protoreflect.Message

func (*UpsertNodeResponse) Reset 

func (x *UpsertNodeResponse) Reset()

func (*UpsertNodeResponse) String 

func (x *UpsertNodeResponse) String() string

type UpsertPluginRequest 

type UpsertPluginRequest struct {
	Item    *v1.Plugin         `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertPluginRequest) Descriptor deprecated 

func (*UpsertPluginRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpsertPluginRequest.ProtoReflect.Descriptor instead.

func (*UpsertPluginRequest) GetCluster 

func (x *UpsertPluginRequest) GetCluster() *v1.RequestCluster

func (*UpsertPluginRequest) GetItem 

func (x *UpsertPluginRequest) GetItem() *v1.Plugin

func (*UpsertPluginRequest) ProtoMessage 

func (*UpsertPluginRequest) ProtoMessage()

func (*UpsertPluginRequest) ProtoReflect 

func (x *UpsertPluginRequest) ProtoReflect() protoreflect.Message

func (*UpsertPluginRequest) Reset 

func (x *UpsertPluginRequest) Reset()

func (*UpsertPluginRequest) String 

func (x *UpsertPluginRequest) String() string

type UpsertPluginResponse 

type UpsertPluginResponse struct {
	Item *v1.Plugin `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertPluginResponse) Descriptor deprecated 

func (*UpsertPluginResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpsertPluginResponse.ProtoReflect.Descriptor instead.

func (*UpsertPluginResponse) GetItem 

func (x *UpsertPluginResponse) GetItem() *v1.Plugin

func (*UpsertPluginResponse) ProtoMessage 

func (*UpsertPluginResponse) ProtoMessage()

func (*UpsertPluginResponse) ProtoReflect 

func (x *UpsertPluginResponse) ProtoReflect() protoreflect.Message

func (*UpsertPluginResponse) Reset 

func (x *UpsertPluginResponse) Reset()

func (*UpsertPluginResponse) String 

func (x *UpsertPluginResponse) String() string

type UpsertRouteRequest 

type UpsertRouteRequest struct {
	Item    *v1.Route          `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertRouteRequest) Descriptor deprecated 

func (*UpsertRouteRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpsertRouteRequest.ProtoReflect.Descriptor instead.

func (*UpsertRouteRequest) GetCluster 

func (x *UpsertRouteRequest) GetCluster() *v1.RequestCluster

func (*UpsertRouteRequest) GetItem 

func (x *UpsertRouteRequest) GetItem() *v1.Route

func (*UpsertRouteRequest) ProtoMessage 

func (*UpsertRouteRequest) ProtoMessage()

func (*UpsertRouteRequest) ProtoReflect 

func (x *UpsertRouteRequest) ProtoReflect() protoreflect.Message

func (*UpsertRouteRequest) Reset 

func (x *UpsertRouteRequest) Reset()

func (*UpsertRouteRequest) String 

func (x *UpsertRouteRequest) String() string

type UpsertRouteResponse 

type UpsertRouteResponse struct {
	Item *v1.Route `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertRouteResponse) Descriptor deprecated 

func (*UpsertRouteResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpsertRouteResponse.ProtoReflect.Descriptor instead.

func (*UpsertRouteResponse) GetItem 

func (x *UpsertRouteResponse) GetItem() *v1.Route

func (*UpsertRouteResponse) ProtoMessage 

func (*UpsertRouteResponse) ProtoMessage()

func (*UpsertRouteResponse) ProtoReflect 

func (x *UpsertRouteResponse) ProtoReflect() protoreflect.Message

func (*UpsertRouteResponse) Reset 

func (x *UpsertRouteResponse) Reset()

func (*UpsertRouteResponse) String 

func (x *UpsertRouteResponse) String() string

type UpsertSNIRequest 

type UpsertSNIRequest struct {
	Item    *v1.SNI            `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertSNIRequest) Descriptor deprecated 

func (*UpsertSNIRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpsertSNIRequest.ProtoReflect.Descriptor instead.

func (*UpsertSNIRequest) GetCluster 

func (x *UpsertSNIRequest) GetCluster() *v1.RequestCluster

func (*UpsertSNIRequest) GetItem 

func (x *UpsertSNIRequest) GetItem() *v1.SNI

func (*UpsertSNIRequest) ProtoMessage 

func (*UpsertSNIRequest) ProtoMessage()

func (*UpsertSNIRequest) ProtoReflect 

func (x *UpsertSNIRequest) ProtoReflect() protoreflect.Message

func (*UpsertSNIRequest) Reset 

func (x *UpsertSNIRequest) Reset()

func (*UpsertSNIRequest) String 

func (x *UpsertSNIRequest) String() string

type UpsertSNIResponse 

type UpsertSNIResponse struct {
	Item *v1.SNI `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertSNIResponse) Descriptor deprecated 

func (*UpsertSNIResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpsertSNIResponse.ProtoReflect.Descriptor instead.

func (*UpsertSNIResponse) GetItem 

func (x *UpsertSNIResponse) GetItem() *v1.SNI

func (*UpsertSNIResponse) ProtoMessage 

func (*UpsertSNIResponse) ProtoMessage()

func (*UpsertSNIResponse) ProtoReflect 

func (x *UpsertSNIResponse) ProtoReflect() protoreflect.Message

func (*UpsertSNIResponse) Reset 

func (x *UpsertSNIResponse) Reset()

func (*UpsertSNIResponse) String 

func (x *UpsertSNIResponse) String() string

type UpsertServiceRequest 

type UpsertServiceRequest struct {
	Item    *v1.Service        `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertServiceRequest) Descriptor deprecated 

func (*UpsertServiceRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpsertServiceRequest.ProtoReflect.Descriptor instead.

func (*UpsertServiceRequest) GetCluster 

func (x *UpsertServiceRequest) GetCluster() *v1.RequestCluster

func (*UpsertServiceRequest) GetItem 

func (x *UpsertServiceRequest) GetItem() *v1.Service

func (*UpsertServiceRequest) ProtoMessage 

func (*UpsertServiceRequest) ProtoMessage()

func (*UpsertServiceRequest) ProtoReflect 

func (x *UpsertServiceRequest) ProtoReflect() protoreflect.Message

func (*UpsertServiceRequest) Reset 

func (x *UpsertServiceRequest) Reset()

func (*UpsertServiceRequest) String 

func (x *UpsertServiceRequest) String() string

type UpsertServiceResponse 

type UpsertServiceResponse struct {
	Item *v1.Service `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertServiceResponse) Descriptor deprecated 

func (*UpsertServiceResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpsertServiceResponse.ProtoReflect.Descriptor instead.

func (*UpsertServiceResponse) GetItem 

func (x *UpsertServiceResponse) GetItem() *v1.Service

func (*UpsertServiceResponse) ProtoMessage 

func (*UpsertServiceResponse) ProtoMessage()

func (*UpsertServiceResponse) ProtoReflect 

func (x *UpsertServiceResponse) ProtoReflect() protoreflect.Message

func (*UpsertServiceResponse) Reset 

func (x *UpsertServiceResponse) Reset()

func (*UpsertServiceResponse) String 

func (x *UpsertServiceResponse) String() string

type UpsertTargetRequest 

type UpsertTargetRequest struct {
	Item    *v1.Target         `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertTargetRequest) Descriptor deprecated 

func (*UpsertTargetRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpsertTargetRequest.ProtoReflect.Descriptor instead.

func (*UpsertTargetRequest) GetCluster 

func (x *UpsertTargetRequest) GetCluster() *v1.RequestCluster

func (*UpsertTargetRequest) GetItem 

func (x *UpsertTargetRequest) GetItem() *v1.Target

func (*UpsertTargetRequest) ProtoMessage 

func (*UpsertTargetRequest) ProtoMessage()

func (*UpsertTargetRequest) ProtoReflect 

func (x *UpsertTargetRequest) ProtoReflect() protoreflect.Message

func (*UpsertTargetRequest) Reset 

func (x *UpsertTargetRequest) Reset()

func (*UpsertTargetRequest) String 

func (x *UpsertTargetRequest) String() string

type UpsertTargetResponse 

type UpsertTargetResponse struct {
	Item *v1.Target `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertTargetResponse) Descriptor deprecated 

func (*UpsertTargetResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpsertTargetResponse.ProtoReflect.Descriptor instead.

func (*UpsertTargetResponse) GetItem 

func (x *UpsertTargetResponse) GetItem() *v1.Target

func (*UpsertTargetResponse) ProtoMessage 

func (*UpsertTargetResponse) ProtoMessage()

func (*UpsertTargetResponse) ProtoReflect 

func (x *UpsertTargetResponse) ProtoReflect() protoreflect.Message

func (*UpsertTargetResponse) Reset 

func (x *UpsertTargetResponse) Reset()

func (*UpsertTargetResponse) String 

func (x *UpsertTargetResponse) String() string

type UpsertUpstreamRequest 

type UpsertUpstreamRequest struct {
	Item    *v1.Upstream       `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	Cluster *v1.RequestCluster `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertUpstreamRequest) Descriptor deprecated 

func (*UpsertUpstreamRequest) Descriptor() ([]byte, []int)

Deprecated: Use UpsertUpstreamRequest.ProtoReflect.Descriptor instead.

func (*UpsertUpstreamRequest) GetCluster 

func (x *UpsertUpstreamRequest) GetCluster() *v1.RequestCluster

func (*UpsertUpstreamRequest) GetItem 

func (x *UpsertUpstreamRequest) GetItem() *v1.Upstream

func (*UpsertUpstreamRequest) ProtoMessage 

func (*UpsertUpstreamRequest) ProtoMessage()

func (*UpsertUpstreamRequest) ProtoReflect 

func (x *UpsertUpstreamRequest) ProtoReflect() protoreflect.Message

func (*UpsertUpstreamRequest) Reset 

func (x *UpsertUpstreamRequest) Reset()

func (*UpsertUpstreamRequest) String 

func (x *UpsertUpstreamRequest) String() string

type UpsertUpstreamResponse 

type UpsertUpstreamResponse struct {
	Item *v1.Upstream `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*UpsertUpstreamResponse) Descriptor deprecated 

func (*UpsertUpstreamResponse) Descriptor() ([]byte, []int)

Deprecated: Use UpsertUpstreamResponse.ProtoReflect.Descriptor instead.

func (*UpsertUpstreamResponse) GetItem 

func (x *UpsertUpstreamResponse) GetItem() *v1.Upstream

func (*UpsertUpstreamResponse) ProtoMessage 

func (*UpsertUpstreamResponse) ProtoMessage()

func (*UpsertUpstreamResponse) ProtoReflect 

func (x *UpsertUpstreamResponse) ProtoReflect() protoreflect.Message

func (*UpsertUpstreamResponse) Reset 

func (x *UpsertUpstreamResponse) Reset()

func (*UpsertUpstreamResponse) String 

func (x *UpsertUpstreamResponse) String() string

type UpstreamServiceClient 

type UpstreamServiceClient interface {
	GetUpstream(ctx context.Context, in *GetUpstreamRequest, opts ...grpc.CallOption) (*GetUpstreamResponse, error)
	CreateUpstream(ctx context.Context, in *CreateUpstreamRequest, opts ...grpc.CallOption) (*CreateUpstreamResponse, error)
	UpsertUpstream(ctx context.Context, in *UpsertUpstreamRequest, opts ...grpc.CallOption) (*UpsertUpstreamResponse, error)
	DeleteUpstream(ctx context.Context, in *DeleteUpstreamRequest, opts ...grpc.CallOption) (*DeleteUpstreamResponse, error)
	ListUpstreams(ctx context.Context, in *ListUpstreamsRequest, opts ...grpc.CallOption) (*ListUpstreamsResponse, error)
}

UpstreamServiceClient is the client API for UpstreamService service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.

func NewUpstreamServiceClient 

func NewUpstreamServiceClient(cc grpc.ClientConnInterface) UpstreamServiceClient

type UpstreamServiceServer 

type UpstreamServiceServer interface {
	GetUpstream(context.Context, *GetUpstreamRequest) (*GetUpstreamResponse, error)
	CreateUpstream(context.Context, *CreateUpstreamRequest) (*CreateUpstreamResponse, error)
	UpsertUpstream(context.Context, *UpsertUpstreamRequest) (*UpsertUpstreamResponse, error)
	DeleteUpstream(context.Context, *DeleteUpstreamRequest) (*DeleteUpstreamResponse, error)
	ListUpstreams(context.Context, *ListUpstreamsRequest) (*ListUpstreamsResponse, error)
	// contains filtered or unexported methods
}

UpstreamServiceServer is the server API for UpstreamService service. All implementations must embed UnimplementedUpstreamServiceServer for forward compatibility

type ValidateCACertificateSchemaRequest 

type ValidateCACertificateSchemaRequest struct {
	Item *v1.CACertificate `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidateCACertificateSchemaRequest) Descriptor deprecated 

func (*ValidateCACertificateSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidateCACertificateSchemaRequest.ProtoReflect.Descriptor instead.

func (*ValidateCACertificateSchemaRequest) GetItem 

func (x *ValidateCACertificateSchemaRequest) GetItem() *v1.CACertificate

func (*ValidateCACertificateSchemaRequest) ProtoMessage 

func (*ValidateCACertificateSchemaRequest) ProtoMessage()

func (*ValidateCACertificateSchemaRequest) ProtoReflect 

func (x *ValidateCACertificateSchemaRequest) ProtoReflect() protoreflect.Message

func (*ValidateCACertificateSchemaRequest) Reset 

func (x *ValidateCACertificateSchemaRequest) Reset()

func (*ValidateCACertificateSchemaRequest) String 

func (x *ValidateCACertificateSchemaRequest) String() string

type ValidateCACertificateSchemaResponse 

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

func (*ValidateCACertificateSchemaResponse) Descriptor deprecated 

func (*ValidateCACertificateSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidateCACertificateSchemaResponse.ProtoReflect.Descriptor instead.

func (*ValidateCACertificateSchemaResponse) ProtoMessage 

func (*ValidateCACertificateSchemaResponse) ProtoMessage()

func (*ValidateCACertificateSchemaResponse) ProtoReflect 

func (x *ValidateCACertificateSchemaResponse) ProtoReflect() protoreflect.Message

func (*ValidateCACertificateSchemaResponse) Reset 

func (x *ValidateCACertificateSchemaResponse) Reset()

func (*ValidateCACertificateSchemaResponse) String 

func (x *ValidateCACertificateSchemaResponse) String() string

type ValidateCertificateSchemaRequest 

type ValidateCertificateSchemaRequest struct {
	Item *v1.Certificate `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidateCertificateSchemaRequest) Descriptor deprecated 

func (*ValidateCertificateSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidateCertificateSchemaRequest.ProtoReflect.Descriptor instead.

func (*ValidateCertificateSchemaRequest) GetItem 

func (x *ValidateCertificateSchemaRequest) GetItem() *v1.Certificate

func (*ValidateCertificateSchemaRequest) ProtoMessage 

func (*ValidateCertificateSchemaRequest) ProtoMessage()

func (*ValidateCertificateSchemaRequest) ProtoReflect 

func (x *ValidateCertificateSchemaRequest) ProtoReflect() protoreflect.Message

func (*ValidateCertificateSchemaRequest) Reset 

func (x *ValidateCertificateSchemaRequest) Reset()

func (*ValidateCertificateSchemaRequest) String 

func (x *ValidateCertificateSchemaRequest) String() string

type ValidateCertificateSchemaResponse 

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

func (*ValidateCertificateSchemaResponse) Descriptor deprecated 

func (*ValidateCertificateSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidateCertificateSchemaResponse.ProtoReflect.Descriptor instead.

func (*ValidateCertificateSchemaResponse) ProtoMessage 

func (*ValidateCertificateSchemaResponse) ProtoMessage()

func (*ValidateCertificateSchemaResponse) ProtoReflect 

func (x *ValidateCertificateSchemaResponse) ProtoReflect() protoreflect.Message

func (*ValidateCertificateSchemaResponse) Reset 

func (x *ValidateCertificateSchemaResponse) Reset()

func (*ValidateCertificateSchemaResponse) String 

func (x *ValidateCertificateSchemaResponse) String() string

type ValidateConfigHashSchemaRequest 

type ValidateConfigHashSchemaRequest struct {
	Item *v1.ConfigHash `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidateConfigHashSchemaRequest) Descriptor deprecated 

func (*ValidateConfigHashSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidateConfigHashSchemaRequest.ProtoReflect.Descriptor instead.

func (*ValidateConfigHashSchemaRequest) GetItem 

func (x *ValidateConfigHashSchemaRequest) GetItem() *v1.ConfigHash

func (*ValidateConfigHashSchemaRequest) ProtoMessage 

func (*ValidateConfigHashSchemaRequest) ProtoMessage()

func (*ValidateConfigHashSchemaRequest) ProtoReflect 

func (x *ValidateConfigHashSchemaRequest) ProtoReflect() protoreflect.Message

func (*ValidateConfigHashSchemaRequest) Reset 

func (x *ValidateConfigHashSchemaRequest) Reset()

func (*ValidateConfigHashSchemaRequest) String 

func (x *ValidateConfigHashSchemaRequest) String() string

type ValidateConfigHashSchemaResponse 

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

func (*ValidateConfigHashSchemaResponse) Descriptor deprecated 

func (*ValidateConfigHashSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidateConfigHashSchemaResponse.ProtoReflect.Descriptor instead.

func (*ValidateConfigHashSchemaResponse) ProtoMessage 

func (*ValidateConfigHashSchemaResponse) ProtoMessage()

func (*ValidateConfigHashSchemaResponse) ProtoReflect 

func (x *ValidateConfigHashSchemaResponse) ProtoReflect() protoreflect.Message

func (*ValidateConfigHashSchemaResponse) Reset 

func (x *ValidateConfigHashSchemaResponse) Reset()

func (*ValidateConfigHashSchemaResponse) String 

func (x *ValidateConfigHashSchemaResponse) String() string

type ValidateConsumerSchemaRequest 

type ValidateConsumerSchemaRequest struct {
	Item *v1.Consumer `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidateConsumerSchemaRequest) Descriptor deprecated 

func (*ValidateConsumerSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidateConsumerSchemaRequest.ProtoReflect.Descriptor instead.

func (*ValidateConsumerSchemaRequest) GetItem 

func (x *ValidateConsumerSchemaRequest) GetItem() *v1.Consumer

func (*ValidateConsumerSchemaRequest) ProtoMessage 

func (*ValidateConsumerSchemaRequest) ProtoMessage()

func (*ValidateConsumerSchemaRequest) ProtoReflect 

func (x *ValidateConsumerSchemaRequest) ProtoReflect() protoreflect.Message

func (*ValidateConsumerSchemaRequest) Reset 

func (x *ValidateConsumerSchemaRequest) Reset()

func (*ValidateConsumerSchemaRequest) String 

func (x *ValidateConsumerSchemaRequest) String() string

type ValidateConsumerSchemaResponse 

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

func (*ValidateConsumerSchemaResponse) Descriptor deprecated 

func (*ValidateConsumerSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidateConsumerSchemaResponse.ProtoReflect.Descriptor instead.

func (*ValidateConsumerSchemaResponse) ProtoMessage 

func (*ValidateConsumerSchemaResponse) ProtoMessage()

func (*ValidateConsumerSchemaResponse) ProtoReflect 

func (x *ValidateConsumerSchemaResponse) ProtoReflect() protoreflect.Message

func (*ValidateConsumerSchemaResponse) Reset 

func (x *ValidateConsumerSchemaResponse) Reset()

func (*ValidateConsumerSchemaResponse) String 

func (x *ValidateConsumerSchemaResponse) String() string

type ValidateLuaPluginRequest 

type ValidateLuaPluginRequest struct {
	Item *v1.Plugin `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidateLuaPluginRequest) Descriptor deprecated 

func (*ValidateLuaPluginRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidateLuaPluginRequest.ProtoReflect.Descriptor instead.

func (*ValidateLuaPluginRequest) GetItem 

func (x *ValidateLuaPluginRequest) GetItem() *v1.Plugin

func (*ValidateLuaPluginRequest) ProtoMessage 

func (*ValidateLuaPluginRequest) ProtoMessage()

func (*ValidateLuaPluginRequest) ProtoReflect 

func (x *ValidateLuaPluginRequest) ProtoReflect() protoreflect.Message

func (*ValidateLuaPluginRequest) Reset 

func (x *ValidateLuaPluginRequest) Reset()

func (*ValidateLuaPluginRequest) String 

func (x *ValidateLuaPluginRequest) String() string

type ValidateLuaPluginResponse 

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

func (*ValidateLuaPluginResponse) Descriptor deprecated 

func (*ValidateLuaPluginResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidateLuaPluginResponse.ProtoReflect.Descriptor instead.

func (*ValidateLuaPluginResponse) ProtoMessage 

func (*ValidateLuaPluginResponse) ProtoMessage()

func (*ValidateLuaPluginResponse) ProtoReflect 

func (x *ValidateLuaPluginResponse) ProtoReflect() protoreflect.Message

func (*ValidateLuaPluginResponse) Reset 

func (x *ValidateLuaPluginResponse) Reset()

func (*ValidateLuaPluginResponse) String 

func (x *ValidateLuaPluginResponse) String() string

type ValidateNodeSchemaRequest 

type ValidateNodeSchemaRequest struct {
	Item *v1.Node `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidateNodeSchemaRequest) Descriptor deprecated 

func (*ValidateNodeSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidateNodeSchemaRequest.ProtoReflect.Descriptor instead.

func (*ValidateNodeSchemaRequest) GetItem 

func (x *ValidateNodeSchemaRequest) GetItem() *v1.Node

func (*ValidateNodeSchemaRequest) ProtoMessage 

func (*ValidateNodeSchemaRequest) ProtoMessage()

func (*ValidateNodeSchemaRequest) ProtoReflect 

func (x *ValidateNodeSchemaRequest) ProtoReflect() protoreflect.Message

func (*ValidateNodeSchemaRequest) Reset 

func (x *ValidateNodeSchemaRequest) Reset()

func (*ValidateNodeSchemaRequest) String 

func (x *ValidateNodeSchemaRequest) String() string

type ValidateNodeSchemaResponse 

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

func (*ValidateNodeSchemaResponse) Descriptor deprecated 

func (*ValidateNodeSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidateNodeSchemaResponse.ProtoReflect.Descriptor instead.

func (*ValidateNodeSchemaResponse) ProtoMessage 

func (*ValidateNodeSchemaResponse) ProtoMessage()

func (*ValidateNodeSchemaResponse) ProtoReflect 

func (x *ValidateNodeSchemaResponse) ProtoReflect() protoreflect.Message

func (*ValidateNodeSchemaResponse) Reset 

func (x *ValidateNodeSchemaResponse) Reset()

func (*ValidateNodeSchemaResponse) String 

func (x *ValidateNodeSchemaResponse) String() string

type ValidatePluginSchemaRequest 

type ValidatePluginSchemaRequest struct {
	Item *v1.Plugin `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidatePluginSchemaRequest) Descriptor deprecated 

func (*ValidatePluginSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidatePluginSchemaRequest.ProtoReflect.Descriptor instead.

func (*ValidatePluginSchemaRequest) GetItem 

func (x *ValidatePluginSchemaRequest) GetItem() *v1.Plugin

func (*ValidatePluginSchemaRequest) ProtoMessage 

func (*ValidatePluginSchemaRequest) ProtoMessage()

func (*ValidatePluginSchemaRequest) ProtoReflect 

func (x *ValidatePluginSchemaRequest) ProtoReflect() protoreflect.Message

func (*ValidatePluginSchemaRequest) Reset 

func (x *ValidatePluginSchemaRequest) Reset()

func (*ValidatePluginSchemaRequest) String 

func (x *ValidatePluginSchemaRequest) String() string

type ValidatePluginSchemaResponse 

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

func (*ValidatePluginSchemaResponse) Descriptor deprecated 

func (*ValidatePluginSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidatePluginSchemaResponse.ProtoReflect.Descriptor instead.

func (*ValidatePluginSchemaResponse) ProtoMessage 

func (*ValidatePluginSchemaResponse) ProtoMessage()

func (*ValidatePluginSchemaResponse) ProtoReflect 

func (x *ValidatePluginSchemaResponse) ProtoReflect() protoreflect.Message

func (*ValidatePluginSchemaResponse) Reset 

func (x *ValidatePluginSchemaResponse) Reset()

func (*ValidatePluginSchemaResponse) String 

func (x *ValidatePluginSchemaResponse) String() string

type ValidateRouteSchemaRequest 

type ValidateRouteSchemaRequest struct {
	Item *v1.Route `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidateRouteSchemaRequest) Descriptor deprecated 

func (*ValidateRouteSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidateRouteSchemaRequest.ProtoReflect.Descriptor instead.

func (*ValidateRouteSchemaRequest) GetItem 

func (x *ValidateRouteSchemaRequest) GetItem() *v1.Route

func (*ValidateRouteSchemaRequest) ProtoMessage 

func (*ValidateRouteSchemaRequest) ProtoMessage()

func (*ValidateRouteSchemaRequest) ProtoReflect 

func (x *ValidateRouteSchemaRequest) ProtoReflect() protoreflect.Message

func (*ValidateRouteSchemaRequest) Reset 

func (x *ValidateRouteSchemaRequest) Reset()

func (*ValidateRouteSchemaRequest) String 

func (x *ValidateRouteSchemaRequest) String() string

type ValidateRouteSchemaResponse 

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

func (*ValidateRouteSchemaResponse) Descriptor deprecated 

func (*ValidateRouteSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidateRouteSchemaResponse.ProtoReflect.Descriptor instead.

func (*ValidateRouteSchemaResponse) ProtoMessage 

func (*ValidateRouteSchemaResponse) ProtoMessage()

func (*ValidateRouteSchemaResponse) ProtoReflect 

func (x *ValidateRouteSchemaResponse) ProtoReflect() protoreflect.Message

func (*ValidateRouteSchemaResponse) Reset 

func (x *ValidateRouteSchemaResponse) Reset()

func (*ValidateRouteSchemaResponse) String 

func (x *ValidateRouteSchemaResponse) String() string

type ValidateSNISchemaRequest 

type ValidateSNISchemaRequest struct {
	Item *v1.SNI `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidateSNISchemaRequest) Descriptor deprecated 

func (*ValidateSNISchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidateSNISchemaRequest.ProtoReflect.Descriptor instead.

func (*ValidateSNISchemaRequest) GetItem 

func (x *ValidateSNISchemaRequest) GetItem() *v1.SNI

func (*ValidateSNISchemaRequest) ProtoMessage 

func (*ValidateSNISchemaRequest) ProtoMessage()

func (*ValidateSNISchemaRequest) ProtoReflect 

func (x *ValidateSNISchemaRequest) ProtoReflect() protoreflect.Message

func (*ValidateSNISchemaRequest) Reset 

func (x *ValidateSNISchemaRequest) Reset()

func (*ValidateSNISchemaRequest) String 

func (x *ValidateSNISchemaRequest) String() string

type ValidateSNISchemaResponse 

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

func (*ValidateSNISchemaResponse) Descriptor deprecated 

func (*ValidateSNISchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidateSNISchemaResponse.ProtoReflect.Descriptor instead.

func (*ValidateSNISchemaResponse) ProtoMessage 

func (*ValidateSNISchemaResponse) ProtoMessage()

func (*ValidateSNISchemaResponse) ProtoReflect 

func (x *ValidateSNISchemaResponse) ProtoReflect() protoreflect.Message

func (*ValidateSNISchemaResponse) Reset 

func (x *ValidateSNISchemaResponse) Reset()

func (*ValidateSNISchemaResponse) String 

func (x *ValidateSNISchemaResponse) String() string

type ValidateServiceSchemaRequest 

type ValidateServiceSchemaRequest struct {
	Item *v1.Service `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidateServiceSchemaRequest) Descriptor deprecated 

func (*ValidateServiceSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidateServiceSchemaRequest.ProtoReflect.Descriptor instead.

func (*ValidateServiceSchemaRequest) GetItem 

func (x *ValidateServiceSchemaRequest) GetItem() *v1.Service

func (*ValidateServiceSchemaRequest) ProtoMessage 

func (*ValidateServiceSchemaRequest) ProtoMessage()

func (*ValidateServiceSchemaRequest) ProtoReflect 

func (x *ValidateServiceSchemaRequest) ProtoReflect() protoreflect.Message

func (*ValidateServiceSchemaRequest) Reset 

func (x *ValidateServiceSchemaRequest) Reset()

func (*ValidateServiceSchemaRequest) String 

func (x *ValidateServiceSchemaRequest) String() string

type ValidateServiceSchemaResponse 

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

func (*ValidateServiceSchemaResponse) Descriptor deprecated 

func (*ValidateServiceSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidateServiceSchemaResponse.ProtoReflect.Descriptor instead.

func (*ValidateServiceSchemaResponse) ProtoMessage 

func (*ValidateServiceSchemaResponse) ProtoMessage()

func (*ValidateServiceSchemaResponse) ProtoReflect 

func (x *ValidateServiceSchemaResponse) ProtoReflect() protoreflect.Message

func (*ValidateServiceSchemaResponse) Reset 

func (x *ValidateServiceSchemaResponse) Reset()

func (*ValidateServiceSchemaResponse) String 

func (x *ValidateServiceSchemaResponse) String() string

type ValidateTargetSchemaRequest 

type ValidateTargetSchemaRequest struct {
	Item *v1.Target `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidateTargetSchemaRequest) Descriptor deprecated 

func (*ValidateTargetSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidateTargetSchemaRequest.ProtoReflect.Descriptor instead.

func (*ValidateTargetSchemaRequest) GetItem 

func (x *ValidateTargetSchemaRequest) GetItem() *v1.Target

func (*ValidateTargetSchemaRequest) ProtoMessage 

func (*ValidateTargetSchemaRequest) ProtoMessage()

func (*ValidateTargetSchemaRequest) ProtoReflect 

func (x *ValidateTargetSchemaRequest) ProtoReflect() protoreflect.Message

func (*ValidateTargetSchemaRequest) Reset 

func (x *ValidateTargetSchemaRequest) Reset()

func (*ValidateTargetSchemaRequest) String 

func (x *ValidateTargetSchemaRequest) String() string

type ValidateTargetSchemaResponse 

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

func (*ValidateTargetSchemaResponse) Descriptor deprecated 

func (*ValidateTargetSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidateTargetSchemaResponse.ProtoReflect.Descriptor instead.

func (*ValidateTargetSchemaResponse) ProtoMessage 

func (*ValidateTargetSchemaResponse) ProtoMessage()

func (*ValidateTargetSchemaResponse) ProtoReflect 

func (x *ValidateTargetSchemaResponse) ProtoReflect() protoreflect.Message

func (*ValidateTargetSchemaResponse) Reset 

func (x *ValidateTargetSchemaResponse) Reset()

func (*ValidateTargetSchemaResponse) String 

func (x *ValidateTargetSchemaResponse) String() string

type ValidateUpstreamSchemaRequest 

type ValidateUpstreamSchemaRequest struct {
	Item *v1.Upstream `protobuf:"bytes,1,opt,name=item,proto3" json:"item,omitempty"`
	// contains filtered or unexported fields
}

func (*ValidateUpstreamSchemaRequest) Descriptor deprecated 

func (*ValidateUpstreamSchemaRequest) Descriptor() ([]byte, []int)

Deprecated: Use ValidateUpstreamSchemaRequest.ProtoReflect.Descriptor instead.

func (*ValidateUpstreamSchemaRequest) GetItem 

func (x *ValidateUpstreamSchemaRequest) GetItem() *v1.Upstream

func (*ValidateUpstreamSchemaRequest) ProtoMessage 

func (*ValidateUpstreamSchemaRequest) ProtoMessage()

func (*ValidateUpstreamSchemaRequest) ProtoReflect 

func (x *ValidateUpstreamSchemaRequest) ProtoReflect() protoreflect.Message

func (*ValidateUpstreamSchemaRequest) Reset 

func (x *ValidateUpstreamSchemaRequest) Reset()

func (*ValidateUpstreamSchemaRequest) String 

func (x *ValidateUpstreamSchemaRequest) String() string

type ValidateUpstreamSchemaResponse 

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

func (*ValidateUpstreamSchemaResponse) Descriptor deprecated 

func (*ValidateUpstreamSchemaResponse) Descriptor() ([]byte, []int)

Deprecated: Use ValidateUpstreamSchemaResponse.ProtoReflect.Descriptor instead.

func (*ValidateUpstreamSchemaResponse) ProtoMessage 

func (*ValidateUpstreamSchemaResponse) ProtoMessage()

func (*ValidateUpstreamSchemaResponse) ProtoReflect 

func (x *ValidateUpstreamSchemaResponse) ProtoReflect() protoreflect.Message

func (*ValidateUpstreamSchemaResponse) Reset 

func (x *ValidateUpstreamSchemaResponse) Reset()

func (*ValidateUpstreamSchemaResponse) String 

func (x *ValidateUpstreamSchemaResponse) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.