// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v7.35.1
// source: envoy/api/v2/core/grpc_service.proto

package core

import (
	_ "github.com/cncf/xds/go/udpa/annotations"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	anypb "google.golang.org/protobuf/types/known/anypb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	structpb "google.golang.org/protobuf/types/known/structpb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// gRPC service configuration. This is used by :ref:`ApiConfigSource
// <envoy_api_msg_core.ApiConfigSource>` and filter configurations.
// [#next-free-field: 6]
type GrpcService struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to TargetSpecifier:
	//
	//	*GrpcService_EnvoyGrpc_
	//	*GrpcService_GoogleGrpc_
	TargetSpecifier isGrpcService_TargetSpecifier `protobuf_oneof:"target_specifier"`
	// The timeout for the gRPC request. This is the timeout for a specific
	// request.
	Timeout *durationpb.Duration `protobuf:"bytes,3,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// Additional metadata to include in streams initiated to the GrpcService.
	// This can be used for scenarios in which additional ad hoc authorization
	// headers (e.g. “x-foo-bar: baz-key“) are to be injected.
	InitialMetadata []*HeaderValue `protobuf:"bytes,5,rep,name=initial_metadata,json=initialMetadata,proto3" json:"initial_metadata,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *GrpcService) Reset() {
	*x = GrpcService{}
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GrpcService) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GrpcService) ProtoMessage() {}

func (x *GrpcService) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GrpcService.ProtoReflect.Descriptor instead.
func (*GrpcService) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP(), []int{0}
}

func (x *GrpcService) GetTargetSpecifier() isGrpcService_TargetSpecifier {
	if x != nil {
		return x.TargetSpecifier
	}
	return nil
}

func (x *GrpcService) GetEnvoyGrpc() *GrpcService_EnvoyGrpc {
	if x != nil {
		if x, ok := x.TargetSpecifier.(*GrpcService_EnvoyGrpc_); ok {
			return x.EnvoyGrpc
		}
	}
	return nil
}

func (x *GrpcService) GetGoogleGrpc() *GrpcService_GoogleGrpc {
	if x != nil {
		if x, ok := x.TargetSpecifier.(*GrpcService_GoogleGrpc_); ok {
			return x.GoogleGrpc
		}
	}
	return nil
}

func (x *GrpcService) GetTimeout() *durationpb.Duration {
	if x != nil {
		return x.Timeout
	}
	return nil
}

func (x *GrpcService) GetInitialMetadata() []*HeaderValue {
	if x != nil {
		return x.InitialMetadata
	}
	return nil
}

type isGrpcService_TargetSpecifier interface {
	isGrpcService_TargetSpecifier()
}

type GrpcService_EnvoyGrpc_ struct {
	// Envoy's in-built gRPC client.
	// See the :ref:`gRPC services overview <arch_overview_grpc_services>`
	// documentation for discussion on gRPC client selection.
	EnvoyGrpc *GrpcService_EnvoyGrpc `protobuf:"bytes,1,opt,name=envoy_grpc,json=envoyGrpc,proto3,oneof"`
}

type GrpcService_GoogleGrpc_ struct {
	// `Google C++ gRPC client <https://github.com/grpc/grpc>`_
	// See the :ref:`gRPC services overview <arch_overview_grpc_services>`
	// documentation for discussion on gRPC client selection.
	GoogleGrpc *GrpcService_GoogleGrpc `protobuf:"bytes,2,opt,name=google_grpc,json=googleGrpc,proto3,oneof"`
}

func (*GrpcService_EnvoyGrpc_) isGrpcService_TargetSpecifier() {}

func (*GrpcService_GoogleGrpc_) isGrpcService_TargetSpecifier() {}

type GrpcService_EnvoyGrpc struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the upstream gRPC cluster. SSL credentials will be supplied
	// in the :ref:`Cluster <envoy_api_msg_Cluster>` :ref:`transport_socket
	// <envoy_api_field_Cluster.transport_socket>`.
	ClusterName   string `protobuf:"bytes,1,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GrpcService_EnvoyGrpc) Reset() {
	*x = GrpcService_EnvoyGrpc{}
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GrpcService_EnvoyGrpc) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GrpcService_EnvoyGrpc) ProtoMessage() {}

func (x *GrpcService_EnvoyGrpc) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GrpcService_EnvoyGrpc.ProtoReflect.Descriptor instead.
func (*GrpcService_EnvoyGrpc) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP(), []int{0, 0}
}

func (x *GrpcService_EnvoyGrpc) GetClusterName() string {
	if x != nil {
		return x.ClusterName
	}
	return ""
}

// [#next-free-field: 7]
type GrpcService_GoogleGrpc struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The target URI when using the `Google C++ gRPC client
	// <https://github.com/grpc/grpc>`_. SSL credentials will be supplied in
	// :ref:`channel_credentials <envoy_api_field_core.GrpcService.GoogleGrpc.channel_credentials>`.
	TargetUri          string                                     `protobuf:"bytes,1,opt,name=target_uri,json=targetUri,proto3" json:"target_uri,omitempty"`
	ChannelCredentials *GrpcService_GoogleGrpc_ChannelCredentials `protobuf:"bytes,2,opt,name=channel_credentials,json=channelCredentials,proto3" json:"channel_credentials,omitempty"`
	// A set of call credentials that can be composed with `channel credentials
	// <https://grpc.io/docs/guides/auth.html#credential-types>`_.
	CallCredentials []*GrpcService_GoogleGrpc_CallCredentials `protobuf:"bytes,3,rep,name=call_credentials,json=callCredentials,proto3" json:"call_credentials,omitempty"`
	// The human readable prefix to use when emitting statistics for the gRPC
	// service.
	//
	// .. csv-table::
	//
	//	:header: Name, Type, Description
	//	:widths: 1, 1, 2
	//
	//	streams_total, Counter, Total number of streams opened
	//	streams_closed_<gRPC status code>, Counter, Total streams closed with <gRPC status code>
	StatPrefix string `protobuf:"bytes,4,opt,name=stat_prefix,json=statPrefix,proto3" json:"stat_prefix,omitempty"`
	// The name of the Google gRPC credentials factory to use. This must have been registered with
	// Envoy. If this is empty, a default credentials factory will be used that sets up channel
	// credentials based on other configuration parameters.
	CredentialsFactoryName string `protobuf:"bytes,5,opt,name=credentials_factory_name,json=credentialsFactoryName,proto3" json:"credentials_factory_name,omitempty"`
	// Additional configuration for site-specific customizations of the Google
	// gRPC library.
	Config        *structpb.Struct `protobuf:"bytes,6,opt,name=config,proto3" json:"config,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GrpcService_GoogleGrpc) Reset() {
	*x = GrpcService_GoogleGrpc{}
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GrpcService_GoogleGrpc) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GrpcService_GoogleGrpc) ProtoMessage() {}

func (x *GrpcService_GoogleGrpc) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GrpcService_GoogleGrpc.ProtoReflect.Descriptor instead.
func (*GrpcService_GoogleGrpc) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP(), []int{0, 1}
}

func (x *GrpcService_GoogleGrpc) GetTargetUri() string {
	if x != nil {
		return x.TargetUri
	}
	return ""
}

func (x *GrpcService_GoogleGrpc) GetChannelCredentials() *GrpcService_GoogleGrpc_ChannelCredentials {
	if x != nil {
		return x.ChannelCredentials
	}
	return nil
}

func (x *GrpcService_GoogleGrpc) GetCallCredentials() []*GrpcService_GoogleGrpc_CallCredentials {
	if x != nil {
		return x.CallCredentials
	}
	return nil
}

func (x *GrpcService_GoogleGrpc) GetStatPrefix() string {
	if x != nil {
		return x.StatPrefix
	}
	return ""
}

func (x *GrpcService_GoogleGrpc) GetCredentialsFactoryName() string {
	if x != nil {
		return x.CredentialsFactoryName
	}
	return ""
}

func (x *GrpcService_GoogleGrpc) GetConfig() *structpb.Struct {
	if x != nil {
		return x.Config
	}
	return nil
}

// See https://grpc.io/grpc/cpp/structgrpc_1_1_ssl_credentials_options.html.
type GrpcService_GoogleGrpc_SslCredentials struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// PEM encoded server root certificates.
	RootCerts *DataSource `protobuf:"bytes,1,opt,name=root_certs,json=rootCerts,proto3" json:"root_certs,omitempty"`
	// PEM encoded client private key.
	PrivateKey *DataSource `protobuf:"bytes,2,opt,name=private_key,json=privateKey,proto3" json:"private_key,omitempty"`
	// PEM encoded client certificate chain.
	CertChain     *DataSource `protobuf:"bytes,3,opt,name=cert_chain,json=certChain,proto3" json:"cert_chain,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GrpcService_GoogleGrpc_SslCredentials) Reset() {
	*x = GrpcService_GoogleGrpc_SslCredentials{}
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GrpcService_GoogleGrpc_SslCredentials) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GrpcService_GoogleGrpc_SslCredentials) ProtoMessage() {}

func (x *GrpcService_GoogleGrpc_SslCredentials) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GrpcService_GoogleGrpc_SslCredentials.ProtoReflect.Descriptor instead.
func (*GrpcService_GoogleGrpc_SslCredentials) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP(), []int{0, 1, 0}
}

func (x *GrpcService_GoogleGrpc_SslCredentials) GetRootCerts() *DataSource {
	if x != nil {
		return x.RootCerts
	}
	return nil
}

func (x *GrpcService_GoogleGrpc_SslCredentials) GetPrivateKey() *DataSource {
	if x != nil {
		return x.PrivateKey
	}
	return nil
}

func (x *GrpcService_GoogleGrpc_SslCredentials) GetCertChain() *DataSource {
	if x != nil {
		return x.CertChain
	}
	return nil
}

// Local channel credentials. Only UDS is supported for now.
// See https://github.com/grpc/grpc/pull/15909.
type GrpcService_GoogleGrpc_GoogleLocalCredentials struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GrpcService_GoogleGrpc_GoogleLocalCredentials) Reset() {
	*x = GrpcService_GoogleGrpc_GoogleLocalCredentials{}
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GrpcService_GoogleGrpc_GoogleLocalCredentials) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GrpcService_GoogleGrpc_GoogleLocalCredentials) ProtoMessage() {}

func (x *GrpcService_GoogleGrpc_GoogleLocalCredentials) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GrpcService_GoogleGrpc_GoogleLocalCredentials.ProtoReflect.Descriptor instead.
func (*GrpcService_GoogleGrpc_GoogleLocalCredentials) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP(), []int{0, 1, 1}
}

// See https://grpc.io/docs/guides/auth.html#credential-types to understand Channel and Call
// credential types.
type GrpcService_GoogleGrpc_ChannelCredentials struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to CredentialSpecifier:
	//
	//	*GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials
	//	*GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault
	//	*GrpcService_GoogleGrpc_ChannelCredentials_LocalCredentials
	CredentialSpecifier isGrpcService_GoogleGrpc_ChannelCredentials_CredentialSpecifier `protobuf_oneof:"credential_specifier"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *GrpcService_GoogleGrpc_ChannelCredentials) Reset() {
	*x = GrpcService_GoogleGrpc_ChannelCredentials{}
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GrpcService_GoogleGrpc_ChannelCredentials) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GrpcService_GoogleGrpc_ChannelCredentials) ProtoMessage() {}

func (x *GrpcService_GoogleGrpc_ChannelCredentials) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GrpcService_GoogleGrpc_ChannelCredentials.ProtoReflect.Descriptor instead.
func (*GrpcService_GoogleGrpc_ChannelCredentials) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP(), []int{0, 1, 2}
}

func (x *GrpcService_GoogleGrpc_ChannelCredentials) GetCredentialSpecifier() isGrpcService_GoogleGrpc_ChannelCredentials_CredentialSpecifier {
	if x != nil {
		return x.CredentialSpecifier
	}
	return nil
}

func (x *GrpcService_GoogleGrpc_ChannelCredentials) GetSslCredentials() *GrpcService_GoogleGrpc_SslCredentials {
	if x != nil {
		if x, ok := x.CredentialSpecifier.(*GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials); ok {
			return x.SslCredentials
		}
	}
	return nil
}

func (x *GrpcService_GoogleGrpc_ChannelCredentials) GetGoogleDefault() *emptypb.Empty {
	if x != nil {
		if x, ok := x.CredentialSpecifier.(*GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault); ok {
			return x.GoogleDefault
		}
	}
	return nil
}

func (x *GrpcService_GoogleGrpc_ChannelCredentials) GetLocalCredentials() *GrpcService_GoogleGrpc_GoogleLocalCredentials {
	if x != nil {
		if x, ok := x.CredentialSpecifier.(*GrpcService_GoogleGrpc_ChannelCredentials_LocalCredentials); ok {
			return x.LocalCredentials
		}
	}
	return nil
}

type isGrpcService_GoogleGrpc_ChannelCredentials_CredentialSpecifier interface {
	isGrpcService_GoogleGrpc_ChannelCredentials_CredentialSpecifier()
}

type GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials struct {
	SslCredentials *GrpcService_GoogleGrpc_SslCredentials `protobuf:"bytes,1,opt,name=ssl_credentials,json=sslCredentials,proto3,oneof"`
}

type GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault struct {
	// https://grpc.io/grpc/cpp/namespacegrpc.html#a6beb3ac70ff94bd2ebbd89b8f21d1f61
	GoogleDefault *emptypb.Empty `protobuf:"bytes,2,opt,name=google_default,json=googleDefault,proto3,oneof"`
}

type GrpcService_GoogleGrpc_ChannelCredentials_LocalCredentials struct {
	LocalCredentials *GrpcService_GoogleGrpc_GoogleLocalCredentials `protobuf:"bytes,3,opt,name=local_credentials,json=localCredentials,proto3,oneof"`
}

func (*GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials) isGrpcService_GoogleGrpc_ChannelCredentials_CredentialSpecifier() {
}

func (*GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault) isGrpcService_GoogleGrpc_ChannelCredentials_CredentialSpecifier() {
}

func (*GrpcService_GoogleGrpc_ChannelCredentials_LocalCredentials) isGrpcService_GoogleGrpc_ChannelCredentials_CredentialSpecifier() {
}

// [#next-free-field: 8]
type GrpcService_GoogleGrpc_CallCredentials struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to CredentialSpecifier:
	//
	//	*GrpcService_GoogleGrpc_CallCredentials_AccessToken
	//	*GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine
	//	*GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken
	//	*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess
	//	*GrpcService_GoogleGrpc_CallCredentials_GoogleIam
	//	*GrpcService_GoogleGrpc_CallCredentials_FromPlugin
	//	*GrpcService_GoogleGrpc_CallCredentials_StsService_
	CredentialSpecifier isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier `protobuf_oneof:"credential_specifier"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *GrpcService_GoogleGrpc_CallCredentials) Reset() {
	*x = GrpcService_GoogleGrpc_CallCredentials{}
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GrpcService_GoogleGrpc_CallCredentials) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GrpcService_GoogleGrpc_CallCredentials) ProtoMessage() {}

func (x *GrpcService_GoogleGrpc_CallCredentials) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GrpcService_GoogleGrpc_CallCredentials.ProtoReflect.Descriptor instead.
func (*GrpcService_GoogleGrpc_CallCredentials) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP(), []int{0, 1, 3}
}

func (x *GrpcService_GoogleGrpc_CallCredentials) GetCredentialSpecifier() isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier {
	if x != nil {
		return x.CredentialSpecifier
	}
	return nil
}

func (x *GrpcService_GoogleGrpc_CallCredentials) GetAccessToken() string {
	if x != nil {
		if x, ok := x.CredentialSpecifier.(*GrpcService_GoogleGrpc_CallCredentials_AccessToken); ok {
			return x.AccessToken
		}
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials) GetGoogleComputeEngine() *emptypb.Empty {
	if x != nil {
		if x, ok := x.CredentialSpecifier.(*GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine); ok {
			return x.GoogleComputeEngine
		}
	}
	return nil
}

func (x *GrpcService_GoogleGrpc_CallCredentials) GetGoogleRefreshToken() string {
	if x != nil {
		if x, ok := x.CredentialSpecifier.(*GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken); ok {
			return x.GoogleRefreshToken
		}
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials) GetServiceAccountJwtAccess() *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials {
	if x != nil {
		if x, ok := x.CredentialSpecifier.(*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess); ok {
			return x.ServiceAccountJwtAccess
		}
	}
	return nil
}

func (x *GrpcService_GoogleGrpc_CallCredentials) GetGoogleIam() *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials {
	if x != nil {
		if x, ok := x.CredentialSpecifier.(*GrpcService_GoogleGrpc_CallCredentials_GoogleIam); ok {
			return x.GoogleIam
		}
	}
	return nil
}

func (x *GrpcService_GoogleGrpc_CallCredentials) GetFromPlugin() *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin {
	if x != nil {
		if x, ok := x.CredentialSpecifier.(*GrpcService_GoogleGrpc_CallCredentials_FromPlugin); ok {
			return x.FromPlugin
		}
	}
	return nil
}

func (x *GrpcService_GoogleGrpc_CallCredentials) GetStsService() *GrpcService_GoogleGrpc_CallCredentials_StsService {
	if x != nil {
		if x, ok := x.CredentialSpecifier.(*GrpcService_GoogleGrpc_CallCredentials_StsService_); ok {
			return x.StsService
		}
	}
	return nil
}

type isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier interface {
	isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier()
}

type GrpcService_GoogleGrpc_CallCredentials_AccessToken struct {
	// Access token credentials.
	// https://grpc.io/grpc/cpp/namespacegrpc.html#ad3a80da696ffdaea943f0f858d7a360d.
	AccessToken string `protobuf:"bytes,1,opt,name=access_token,json=accessToken,proto3,oneof"`
}

type GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine struct {
	// Google Compute Engine credentials.
	// https://grpc.io/grpc/cpp/namespacegrpc.html#a6beb3ac70ff94bd2ebbd89b8f21d1f61
	GoogleComputeEngine *emptypb.Empty `protobuf:"bytes,2,opt,name=google_compute_engine,json=googleComputeEngine,proto3,oneof"`
}

type GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken struct {
	// Google refresh token credentials.
	// https://grpc.io/grpc/cpp/namespacegrpc.html#a96901c997b91bc6513b08491e0dca37c.
	GoogleRefreshToken string `protobuf:"bytes,3,opt,name=google_refresh_token,json=googleRefreshToken,proto3,oneof"`
}

type GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess struct {
	// Service Account JWT Access credentials.
	// https://grpc.io/grpc/cpp/namespacegrpc.html#a92a9f959d6102461f66ee973d8e9d3aa.
	ServiceAccountJwtAccess *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials `protobuf:"bytes,4,opt,name=service_account_jwt_access,json=serviceAccountJwtAccess,proto3,oneof"`
}

type GrpcService_GoogleGrpc_CallCredentials_GoogleIam struct {
	// Google IAM credentials.
	// https://grpc.io/grpc/cpp/namespacegrpc.html#a9fc1fc101b41e680d47028166e76f9d0.
	GoogleIam *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials `protobuf:"bytes,5,opt,name=google_iam,json=googleIam,proto3,oneof"`
}

type GrpcService_GoogleGrpc_CallCredentials_FromPlugin struct {
	// Custom authenticator credentials.
	// https://grpc.io/grpc/cpp/namespacegrpc.html#a823c6a4b19ffc71fb33e90154ee2ad07.
	// https://grpc.io/docs/guides/auth.html#extending-grpc-to-support-other-authentication-mechanisms.
	FromPlugin *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin `protobuf:"bytes,6,opt,name=from_plugin,json=fromPlugin,proto3,oneof"`
}

type GrpcService_GoogleGrpc_CallCredentials_StsService_ struct {
	// Custom security token service which implements OAuth 2.0 token exchange.
	// https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16
	// See https://github.com/grpc/grpc/pull/19587.
	StsService *GrpcService_GoogleGrpc_CallCredentials_StsService `protobuf:"bytes,7,opt,name=sts_service,json=stsService,proto3,oneof"`
}

func (*GrpcService_GoogleGrpc_CallCredentials_AccessToken) isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier() {
}

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine) isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier() {
}

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken) isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier() {
}

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess) isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier() {
}

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIam) isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier() {
}

func (*GrpcService_GoogleGrpc_CallCredentials_FromPlugin) isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier() {
}

func (*GrpcService_GoogleGrpc_CallCredentials_StsService_) isGrpcService_GoogleGrpc_CallCredentials_CredentialSpecifier() {
}

type GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials struct {
	state                protoimpl.MessageState `protogen:"open.v1"`
	JsonKey              string                 `protobuf:"bytes,1,opt,name=json_key,json=jsonKey,proto3" json:"json_key,omitempty"`
	TokenLifetimeSeconds uint64                 `protobuf:"varint,2,opt,name=token_lifetime_seconds,json=tokenLifetimeSeconds,proto3" json:"token_lifetime_seconds,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

func (x *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Reset() {
	*x = GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials{}
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) ProtoMessage() {}

func (x *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials.ProtoReflect.Descriptor instead.
func (*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP(), []int{0, 1, 3, 0}
}

func (x *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) GetJsonKey() string {
	if x != nil {
		return x.JsonKey
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials) GetTokenLifetimeSeconds() uint64 {
	if x != nil {
		return x.TokenLifetimeSeconds
	}
	return 0
}

type GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials struct {
	state              protoimpl.MessageState `protogen:"open.v1"`
	AuthorizationToken string                 `protobuf:"bytes,1,opt,name=authorization_token,json=authorizationToken,proto3" json:"authorization_token,omitempty"`
	AuthoritySelector  string                 `protobuf:"bytes,2,opt,name=authority_selector,json=authoritySelector,proto3" json:"authority_selector,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Reset() {
	*x = GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials{}
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) ProtoMessage() {}

func (x *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials.ProtoReflect.Descriptor instead.
func (*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP(), []int{0, 1, 3, 1}
}

func (x *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) GetAuthorizationToken() string {
	if x != nil {
		return x.AuthorizationToken
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials) GetAuthoritySelector() string {
	if x != nil {
		return x.AuthoritySelector
	}
	return ""
}

type GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Name  string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to ConfigType:
	//
	//	*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_Config
	//	*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_TypedConfig
	ConfigType    isGrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_ConfigType `protobuf_oneof:"config_type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Reset() {
	*x = GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin{}
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) ProtoMessage() {}

func (x *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin.ProtoReflect.Descriptor instead.
func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP(), []int{0, 1, 3, 2}
}

func (x *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) GetConfigType() isGrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_ConfigType {
	if x != nil {
		return x.ConfigType
	}
	return nil
}

// Deprecated: Marked as deprecated in envoy/api/v2/core/grpc_service.proto.
func (x *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) GetConfig() *structpb.Struct {
	if x != nil {
		if x, ok := x.ConfigType.(*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_Config); ok {
			return x.Config
		}
	}
	return nil
}

func (x *GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin) GetTypedConfig() *anypb.Any {
	if x != nil {
		if x, ok := x.ConfigType.(*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_TypedConfig); ok {
			return x.TypedConfig
		}
	}
	return nil
}

type isGrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_ConfigType interface {
	isGrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_ConfigType()
}

type GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_Config struct {
	// Deprecated: Marked as deprecated in envoy/api/v2/core/grpc_service.proto.
	Config *structpb.Struct `protobuf:"bytes,2,opt,name=config,proto3,oneof"`
}

type GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_TypedConfig struct {
	TypedConfig *anypb.Any `protobuf:"bytes,3,opt,name=typed_config,json=typedConfig,proto3,oneof"`
}

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_Config) isGrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_ConfigType() {
}

func (*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_TypedConfig) isGrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_ConfigType() {
}

// Security token service configuration that allows Google gRPC to
// fetch security token from an OAuth 2.0 authorization server.
// See https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16 and
// https://github.com/grpc/grpc/pull/19587.
// [#next-free-field: 10]
type GrpcService_GoogleGrpc_CallCredentials_StsService struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// URI of the token exchange service that handles token exchange requests.
	// [#comment:TODO(asraa): Add URI validation when implemented. Tracked by
	// https://github.com/bufbuild/protoc-gen-validate/issues/303]
	TokenExchangeServiceUri string `protobuf:"bytes,1,opt,name=token_exchange_service_uri,json=tokenExchangeServiceUri,proto3" json:"token_exchange_service_uri,omitempty"`
	// Location of the target service or resource where the client
	// intends to use the requested security token.
	Resource string `protobuf:"bytes,2,opt,name=resource,proto3" json:"resource,omitempty"`
	// Logical name of the target service where the client intends to
	// use the requested security token.
	Audience string `protobuf:"bytes,3,opt,name=audience,proto3" json:"audience,omitempty"`
	// The desired scope of the requested security token in the
	// context of the service or resource where the token will be used.
	Scope string `protobuf:"bytes,4,opt,name=scope,proto3" json:"scope,omitempty"`
	// Type of the requested security token.
	RequestedTokenType string `protobuf:"bytes,5,opt,name=requested_token_type,json=requestedTokenType,proto3" json:"requested_token_type,omitempty"`
	// The path of subject token, a security token that represents the
	// identity of the party on behalf of whom the request is being made.
	SubjectTokenPath string `protobuf:"bytes,6,opt,name=subject_token_path,json=subjectTokenPath,proto3" json:"subject_token_path,omitempty"`
	// Type of the subject token.
	SubjectTokenType string `protobuf:"bytes,7,opt,name=subject_token_type,json=subjectTokenType,proto3" json:"subject_token_type,omitempty"`
	// The path of actor token, a security token that represents the identity
	// of the acting party. The acting party is authorized to use the
	// requested security token and act on behalf of the subject.
	ActorTokenPath string `protobuf:"bytes,8,opt,name=actor_token_path,json=actorTokenPath,proto3" json:"actor_token_path,omitempty"`
	// Type of the actor token.
	ActorTokenType string `protobuf:"bytes,9,opt,name=actor_token_type,json=actorTokenType,proto3" json:"actor_token_type,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) Reset() {
	*x = GrpcService_GoogleGrpc_CallCredentials_StsService{}
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GrpcService_GoogleGrpc_CallCredentials_StsService) ProtoMessage() {}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_core_grpc_service_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GrpcService_GoogleGrpc_CallCredentials_StsService.ProtoReflect.Descriptor instead.
func (*GrpcService_GoogleGrpc_CallCredentials_StsService) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP(), []int{0, 1, 3, 3}
}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) GetTokenExchangeServiceUri() string {
	if x != nil {
		return x.TokenExchangeServiceUri
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) GetResource() string {
	if x != nil {
		return x.Resource
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) GetAudience() string {
	if x != nil {
		return x.Audience
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) GetScope() string {
	if x != nil {
		return x.Scope
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) GetRequestedTokenType() string {
	if x != nil {
		return x.RequestedTokenType
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) GetSubjectTokenPath() string {
	if x != nil {
		return x.SubjectTokenPath
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) GetSubjectTokenType() string {
	if x != nil {
		return x.SubjectTokenType
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) GetActorTokenPath() string {
	if x != nil {
		return x.ActorTokenPath
	}
	return ""
}

func (x *GrpcService_GoogleGrpc_CallCredentials_StsService) GetActorTokenType() string {
	if x != nil {
		return x.ActorTokenType
	}
	return ""
}

var File_envoy_api_v2_core_grpc_service_proto protoreflect.FileDescriptor

const file_envoy_api_v2_core_grpc_service_proto_rawDesc = "" +
	"\n" +
	"$envoy/api/v2/core/grpc_service.proto\x12\x11envoy.api.v2.core\x1a\x1cenvoy/api/v2/core/base.proto\x1a\x19google/protobuf/any.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1eudpa/annotations/migrate.proto\x1a udpa/annotations/sensitive.proto\x1a\x1dudpa/annotations/status.proto\x1a\x17validate/validate.proto\"\xdb\x16\n" +
	"\vGrpcService\x12I\n" +
	"\n" +
	"envoy_grpc\x18\x01 \x01(\v2(.envoy.api.v2.core.GrpcService.EnvoyGrpcH\x00R\tenvoyGrpc\x12L\n" +
	"\vgoogle_grpc\x18\x02 \x01(\v2).envoy.api.v2.core.GrpcService.GoogleGrpcH\x00R\n" +
	"googleGrpc\x123\n" +
	"\atimeout\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\atimeout\x12I\n" +
	"\x10initial_metadata\x18\x05 \x03(\v2\x1e.envoy.api.v2.core.HeaderValueR\x0finitialMetadata\x1a7\n" +
	"\tEnvoyGrpc\x12*\n" +
	"\fcluster_name\x18\x01 \x01(\tB\a\xfaB\x04r\x02 \x01R\vclusterName\x1a\xda\x13\n" +
	"\n" +
	"GoogleGrpc\x12&\n" +
	"\n" +
	"target_uri\x18\x01 \x01(\tB\a\xfaB\x04r\x02 \x01R\ttargetUri\x12m\n" +
	"\x13channel_credentials\x18\x02 \x01(\v2<.envoy.api.v2.core.GrpcService.GoogleGrpc.ChannelCredentialsR\x12channelCredentials\x12d\n" +
	"\x10call_credentials\x18\x03 \x03(\v29.envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentialsR\x0fcallCredentials\x12(\n" +
	"\vstat_prefix\x18\x04 \x01(\tB\a\xfaB\x04r\x02 \x01R\n" +
	"statPrefix\x128\n" +
	"\x18credentials_factory_name\x18\x05 \x01(\tR\x16credentialsFactoryName\x12/\n" +
	"\x06config\x18\x06 \x01(\v2\x17.google.protobuf.StructR\x06config\x1a\xd4\x01\n" +
	"\x0eSslCredentials\x12<\n" +
	"\n" +
	"root_certs\x18\x01 \x01(\v2\x1d.envoy.api.v2.core.DataSourceR\trootCerts\x12F\n" +
	"\vprivate_key\x18\x02 \x01(\v2\x1d.envoy.api.v2.core.DataSourceB\x06\xb8\xb7\x8b\xa4\x02\x01R\n" +
	"privateKey\x12<\n" +
	"\n" +
	"cert_chain\x18\x03 \x01(\v2\x1d.envoy.api.v2.core.DataSourceR\tcertChain\x1a\x18\n" +
	"\x16GoogleLocalCredentials\x1a\xc8\x02\n" +
	"\x12ChannelCredentials\x12c\n" +
	"\x0fssl_credentials\x18\x01 \x01(\v28.envoy.api.v2.core.GrpcService.GoogleGrpc.SslCredentialsH\x00R\x0esslCredentials\x12?\n" +
	"\x0egoogle_default\x18\x02 \x01(\v2\x16.google.protobuf.EmptyH\x00R\rgoogleDefault\x12o\n" +
	"\x11local_credentials\x18\x03 \x01(\v2@.envoy.api.v2.core.GrpcService.GoogleGrpc.GoogleLocalCredentialsH\x00R\x10localCredentialsB\x1b\n" +
	"\x14credential_specifier\x12\x03\xf8B\x01\x1a\xfd\v\n" +
	"\x0fCallCredentials\x12#\n" +
	"\faccess_token\x18\x01 \x01(\tH\x00R\vaccessToken\x12L\n" +
	"\x15google_compute_engine\x18\x02 \x01(\v2\x16.google.protobuf.EmptyH\x00R\x13googleComputeEngine\x122\n" +
	"\x14google_refresh_token\x18\x03 \x01(\tH\x00R\x12googleRefreshToken\x12\x9b\x01\n" +
	"\x1aservice_account_jwt_access\x18\x04 \x01(\v2\\.envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentialsH\x00R\x17serviceAccountJwtAccess\x12o\n" +
	"\n" +
	"google_iam\x18\x05 \x01(\v2N.envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentialsH\x00R\tgoogleIam\x12z\n" +
	"\vfrom_plugin\x18\x06 \x01(\v2W.envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPluginH\x00R\n" +
	"fromPlugin\x12g\n" +
	"\vsts_service\x18\a \x01(\v2D.envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.StsServiceH\x00R\n" +
	"stsService\x1au\n" +
	"\"ServiceAccountJWTAccessCredentials\x12\x19\n" +
	"\bjson_key\x18\x01 \x01(\tR\ajsonKey\x124\n" +
	"\x16token_lifetime_seconds\x18\x02 \x01(\x04R\x14tokenLifetimeSeconds\x1av\n" +
	"\x14GoogleIAMCredentials\x12/\n" +
	"\x13authorization_token\x18\x01 \x01(\tR\x12authorizationToken\x12-\n" +
	"\x12authority_selector\x18\x02 \x01(\tR\x11authoritySelector\x1a\xb4\x01\n" +
	"\x1dMetadataCredentialsFromPlugin\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x125\n" +
	"\x06config\x18\x02 \x01(\v2\x17.google.protobuf.StructB\x02\x18\x01H\x00R\x06config\x129\n" +
	"\ftyped_config\x18\x03 \x01(\v2\x14.google.protobuf.AnyH\x00R\vtypedConfigB\r\n" +
	"\vconfig_type\x1a\x8b\x03\n" +
	"\n" +
	"StsService\x12;\n" +
	"\x1atoken_exchange_service_uri\x18\x01 \x01(\tR\x17tokenExchangeServiceUri\x12\x1a\n" +
	"\bresource\x18\x02 \x01(\tR\bresource\x12\x1a\n" +
	"\baudience\x18\x03 \x01(\tR\baudience\x12\x14\n" +
	"\x05scope\x18\x04 \x01(\tR\x05scope\x120\n" +
	"\x14requested_token_type\x18\x05 \x01(\tR\x12requestedTokenType\x125\n" +
	"\x12subject_token_path\x18\x06 \x01(\tB\a\xfaB\x04r\x02 \x01R\x10subjectTokenPath\x125\n" +
	"\x12subject_token_type\x18\a \x01(\tB\a\xfaB\x04r\x02 \x01R\x10subjectTokenType\x12(\n" +
	"\x10actor_token_path\x18\b \x01(\tR\x0eactorTokenPath\x12(\n" +
	"\x10actor_token_type\x18\t \x01(\tR\x0eactorTokenTypeB\x1b\n" +
	"\x14credential_specifier\x12\x03\xf8B\x01B\x17\n" +
	"\x10target_specifier\x12\x03\xf8B\x01J\x04\b\x04\x10\x05B\x93\x01\xf2\x98\xfe\x8f\x05\x16\x12\x14envoy.config.core.v3\xba\x80\xc8\xd1\x06\x02\x10\x01\n" +
	"\x1fio.envoyproxy.envoy.api.v2.coreB\x10GrpcServiceProtoP\x01Z8github.com/envoyproxy/go-control-plane/envoy/api/v2/coreb\x06proto3"

var (
	file_envoy_api_v2_core_grpc_service_proto_rawDescOnce sync.Once
	file_envoy_api_v2_core_grpc_service_proto_rawDescData []byte
)

func file_envoy_api_v2_core_grpc_service_proto_rawDescGZIP() []byte {
	file_envoy_api_v2_core_grpc_service_proto_rawDescOnce.Do(func() {
		file_envoy_api_v2_core_grpc_service_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_envoy_api_v2_core_grpc_service_proto_rawDesc), len(file_envoy_api_v2_core_grpc_service_proto_rawDesc)))
	})
	return file_envoy_api_v2_core_grpc_service_proto_rawDescData
}

var file_envoy_api_v2_core_grpc_service_proto_msgTypes = make([]protoimpl.MessageInfo, 11)
var file_envoy_api_v2_core_grpc_service_proto_goTypes = []any{
	(*GrpcService)(nil),                                                               // 0: envoy.api.v2.core.GrpcService
	(*GrpcService_EnvoyGrpc)(nil),                                                     // 1: envoy.api.v2.core.GrpcService.EnvoyGrpc
	(*GrpcService_GoogleGrpc)(nil),                                                    // 2: envoy.api.v2.core.GrpcService.GoogleGrpc
	(*GrpcService_GoogleGrpc_SslCredentials)(nil),                                     // 3: envoy.api.v2.core.GrpcService.GoogleGrpc.SslCredentials
	(*GrpcService_GoogleGrpc_GoogleLocalCredentials)(nil),                             // 4: envoy.api.v2.core.GrpcService.GoogleGrpc.GoogleLocalCredentials
	(*GrpcService_GoogleGrpc_ChannelCredentials)(nil),                                 // 5: envoy.api.v2.core.GrpcService.GoogleGrpc.ChannelCredentials
	(*GrpcService_GoogleGrpc_CallCredentials)(nil),                                    // 6: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials
	(*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials)(nil), // 7: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials
	(*GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials)(nil),               // 8: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials
	(*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin)(nil),      // 9: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin
	(*GrpcService_GoogleGrpc_CallCredentials_StsService)(nil),                         // 10: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.StsService
	(*durationpb.Duration)(nil),                                                       // 11: google.protobuf.Duration
	(*HeaderValue)(nil),                                                               // 12: envoy.api.v2.core.HeaderValue
	(*structpb.Struct)(nil),                                                           // 13: google.protobuf.Struct
	(*DataSource)(nil),                                                                // 14: envoy.api.v2.core.DataSource
	(*emptypb.Empty)(nil),                                                             // 15: google.protobuf.Empty
	(*anypb.Any)(nil),                                                                 // 16: google.protobuf.Any
}
var file_envoy_api_v2_core_grpc_service_proto_depIdxs = []int32{
	1,  // 0: envoy.api.v2.core.GrpcService.envoy_grpc:type_name -> envoy.api.v2.core.GrpcService.EnvoyGrpc
	2,  // 1: envoy.api.v2.core.GrpcService.google_grpc:type_name -> envoy.api.v2.core.GrpcService.GoogleGrpc
	11, // 2: envoy.api.v2.core.GrpcService.timeout:type_name -> google.protobuf.Duration
	12, // 3: envoy.api.v2.core.GrpcService.initial_metadata:type_name -> envoy.api.v2.core.HeaderValue
	5,  // 4: envoy.api.v2.core.GrpcService.GoogleGrpc.channel_credentials:type_name -> envoy.api.v2.core.GrpcService.GoogleGrpc.ChannelCredentials
	6,  // 5: envoy.api.v2.core.GrpcService.GoogleGrpc.call_credentials:type_name -> envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials
	13, // 6: envoy.api.v2.core.GrpcService.GoogleGrpc.config:type_name -> google.protobuf.Struct
	14, // 7: envoy.api.v2.core.GrpcService.GoogleGrpc.SslCredentials.root_certs:type_name -> envoy.api.v2.core.DataSource
	14, // 8: envoy.api.v2.core.GrpcService.GoogleGrpc.SslCredentials.private_key:type_name -> envoy.api.v2.core.DataSource
	14, // 9: envoy.api.v2.core.GrpcService.GoogleGrpc.SslCredentials.cert_chain:type_name -> envoy.api.v2.core.DataSource
	3,  // 10: envoy.api.v2.core.GrpcService.GoogleGrpc.ChannelCredentials.ssl_credentials:type_name -> envoy.api.v2.core.GrpcService.GoogleGrpc.SslCredentials
	15, // 11: envoy.api.v2.core.GrpcService.GoogleGrpc.ChannelCredentials.google_default:type_name -> google.protobuf.Empty
	4,  // 12: envoy.api.v2.core.GrpcService.GoogleGrpc.ChannelCredentials.local_credentials:type_name -> envoy.api.v2.core.GrpcService.GoogleGrpc.GoogleLocalCredentials
	15, // 13: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.google_compute_engine:type_name -> google.protobuf.Empty
	7,  // 14: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.service_account_jwt_access:type_name -> envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials
	8,  // 15: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.google_iam:type_name -> envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials
	9,  // 16: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.from_plugin:type_name -> envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin
	10, // 17: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.sts_service:type_name -> envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.StsService
	13, // 18: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.config:type_name -> google.protobuf.Struct
	16, // 19: envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.typed_config:type_name -> google.protobuf.Any
	20, // [20:20] is the sub-list for method output_type
	20, // [20:20] is the sub-list for method input_type
	20, // [20:20] is the sub-list for extension type_name
	20, // [20:20] is the sub-list for extension extendee
	0,  // [0:20] is the sub-list for field type_name
}

func init() { file_envoy_api_v2_core_grpc_service_proto_init() }
func file_envoy_api_v2_core_grpc_service_proto_init() {
	if File_envoy_api_v2_core_grpc_service_proto != nil {
		return
	}
	file_envoy_api_v2_core_base_proto_init()
	file_envoy_api_v2_core_grpc_service_proto_msgTypes[0].OneofWrappers = []any{
		(*GrpcService_EnvoyGrpc_)(nil),
		(*GrpcService_GoogleGrpc_)(nil),
	}
	file_envoy_api_v2_core_grpc_service_proto_msgTypes[5].OneofWrappers = []any{
		(*GrpcService_GoogleGrpc_ChannelCredentials_SslCredentials)(nil),
		(*GrpcService_GoogleGrpc_ChannelCredentials_GoogleDefault)(nil),
		(*GrpcService_GoogleGrpc_ChannelCredentials_LocalCredentials)(nil),
	}
	file_envoy_api_v2_core_grpc_service_proto_msgTypes[6].OneofWrappers = []any{
		(*GrpcService_GoogleGrpc_CallCredentials_AccessToken)(nil),
		(*GrpcService_GoogleGrpc_CallCredentials_GoogleComputeEngine)(nil),
		(*GrpcService_GoogleGrpc_CallCredentials_GoogleRefreshToken)(nil),
		(*GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJwtAccess)(nil),
		(*GrpcService_GoogleGrpc_CallCredentials_GoogleIam)(nil),
		(*GrpcService_GoogleGrpc_CallCredentials_FromPlugin)(nil),
		(*GrpcService_GoogleGrpc_CallCredentials_StsService_)(nil),
	}
	file_envoy_api_v2_core_grpc_service_proto_msgTypes[9].OneofWrappers = []any{
		(*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_Config)(nil),
		(*GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_TypedConfig)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_envoy_api_v2_core_grpc_service_proto_rawDesc), len(file_envoy_api_v2_core_grpc_service_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   11,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_envoy_api_v2_core_grpc_service_proto_goTypes,
		DependencyIndexes: file_envoy_api_v2_core_grpc_service_proto_depIdxs,
		MessageInfos:      file_envoy_api_v2_core_grpc_service_proto_msgTypes,
	}.Build()
	File_envoy_api_v2_core_grpc_service_proto = out.File
	file_envoy_api_v2_core_grpc_service_proto_goTypes = nil
	file_envoy_api_v2_core_grpc_service_proto_depIdxs = nil
}
