// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v7.35.1
// source: envoy/extensions/wasm/v3/wasm.proto

package wasmv3

import (
	_ "github.com/cncf/xds/go/udpa/annotations"
	_ "github.com/envoyproxy/go-control-plane/envoy/annotations"
	v3 "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	anypb "google.golang.org/protobuf/types/known/anypb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	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)
)

// If there is a fatal error on the VM (e.g. exception, “abort()“), then the policy will be applied.
type FailurePolicy int32

const (
	// No policy is specified. The default policy will be used. The default policy is “FAIL_CLOSED“.
	FailurePolicy_UNSPECIFIED FailurePolicy = 0
	// New plugin instance will be created for the new request if the VM is failed. Note this will only
	// be applied to the following failures:
	//
	// * “proxy_wasm::FailState::RuntimeError“
	//
	// This will fallback to the “FAIL_CLOSED“ for all other failures.
	FailurePolicy_FAIL_RELOAD FailurePolicy = 1
	// All plugins associated with the VM will return an HTTP 503 error.
	FailurePolicy_FAIL_CLOSED FailurePolicy = 2
	// All plugins associated with the VM will be ignored and the filter chain will continue. This
	// makes sense when the plugin is optional.
	FailurePolicy_FAIL_OPEN FailurePolicy = 3
)

// Enum value maps for FailurePolicy.
var (
	FailurePolicy_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "FAIL_RELOAD",
		2: "FAIL_CLOSED",
		3: "FAIL_OPEN",
	}
	FailurePolicy_value = map[string]int32{
		"UNSPECIFIED": 0,
		"FAIL_RELOAD": 1,
		"FAIL_CLOSED": 2,
		"FAIL_OPEN":   3,
	}
)

func (x FailurePolicy) Enum() *FailurePolicy {
	p := new(FailurePolicy)
	*p = x
	return p
}

func (x FailurePolicy) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (FailurePolicy) Descriptor() protoreflect.EnumDescriptor {
	return file_envoy_extensions_wasm_v3_wasm_proto_enumTypes[0].Descriptor()
}

func (FailurePolicy) Type() protoreflect.EnumType {
	return &file_envoy_extensions_wasm_v3_wasm_proto_enumTypes[0]
}

func (x FailurePolicy) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use FailurePolicy.Descriptor instead.
func (FailurePolicy) EnumDescriptor() ([]byte, []int) {
	return file_envoy_extensions_wasm_v3_wasm_proto_rawDescGZIP(), []int{0}
}

type ReloadConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Backoff strategy for the VM failure reload. If not specified, the default 1s base interval
	// will be applied.
	Backoff       *v3.BackoffStrategy `protobuf:"bytes,1,opt,name=backoff,proto3" json:"backoff,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ReloadConfig) ProtoMessage() {}

func (x *ReloadConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_wasm_v3_wasm_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 ReloadConfig.ProtoReflect.Descriptor instead.
func (*ReloadConfig) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_wasm_v3_wasm_proto_rawDescGZIP(), []int{0}
}

func (x *ReloadConfig) GetBackoff() *v3.BackoffStrategy {
	if x != nil {
		return x.Backoff
	}
	return nil
}

// Configuration for restricting Proxy-Wasm capabilities available to modules.
type CapabilityRestrictionConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The Proxy-Wasm capabilities which will be allowed. Capabilities are mapped by
	// name. The “SanitizationConfig“ which each capability maps to is currently unimplemented and ignored,
	// and so should be left empty.
	//
	// The capability names are given in the
	// `Proxy-Wasm ABI <https://github.com/proxy-wasm/spec/tree/master/abi-versions/vNEXT>`_.
	// Additionally, the following WASI capabilities from
	// `this list <https://github.com/WebAssembly/WASI/blob/master/phases/snapshot/docs.md#modules>`_
	// are implemented and can be allowed:
	// “fd_write“, “fd_read“, “fd_seek“, “fd_close“, “fd_fdstat_get“, “environ_get“, “environ_sizes_get“,
	// “args_get“, “args_sizes_get“, “proc_exit“, “clock_time_get“, “random_get“.
	AllowedCapabilities map[string]*SanitizationConfig `protobuf:"bytes,1,rep,name=allowed_capabilities,json=allowedCapabilities,proto3" json:"allowed_capabilities,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*CapabilityRestrictionConfig) ProtoMessage() {}

func (x *CapabilityRestrictionConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_wasm_v3_wasm_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 CapabilityRestrictionConfig.ProtoReflect.Descriptor instead.
func (*CapabilityRestrictionConfig) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_wasm_v3_wasm_proto_rawDescGZIP(), []int{1}
}

func (x *CapabilityRestrictionConfig) GetAllowedCapabilities() map[string]*SanitizationConfig {
	if x != nil {
		return x.AllowedCapabilities
	}
	return nil
}

// Configuration for sanitization of inputs to an allowed capability.
//
// .. note::
//
//	This is currently unimplemented.
type SanitizationConfig struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SanitizationConfig) ProtoMessage() {}

func (x *SanitizationConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_wasm_v3_wasm_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 SanitizationConfig.ProtoReflect.Descriptor instead.
func (*SanitizationConfig) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_wasm_v3_wasm_proto_rawDescGZIP(), []int{2}
}

// Configuration for a Wasm VM.
// [#next-free-field: 8]
type VmConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// An ID which will be used along with a hash of the wasm code (or the name of the registered Null
	// VM plugin) to determine which VM will be used for the plugin. All plugins which use the same
	// “vm_id“ and code will use the same VM. May be left blank. Sharing a VM between plugins can
	// reduce memory utilization and make sharing of data easier which may have security implications.
	// [#comment: TODO: add ref for details.]
	VmId string `protobuf:"bytes,1,opt,name=vm_id,json=vmId,proto3" json:"vm_id,omitempty"`
	// The Wasm runtime type, defaults to the first available Wasm engine used at Envoy build-time.
	// The priority to search for the available engine is: v8 -> wasmtime -> wamr.
	// Available Wasm runtime types are registered as extensions. The following runtimes are included
	// in Envoy code base:
	//
	// .. _extension_envoy.wasm.runtime.null:
	//
	// **envoy.wasm.runtime.null**: Null sandbox, the Wasm module must be compiled and linked into the
	// Envoy binary. The registered name is given in the “code“ field as “inline_string“.
	//
	// .. _extension_envoy.wasm.runtime.v8:
	//
	// **envoy.wasm.runtime.v8**: `V8 <https://v8.dev/>`_-based WebAssembly runtime.
	//
	// .. _extension_envoy.wasm.runtime.wamr:
	//
	// **envoy.wasm.runtime.wamr**: `WAMR <https://github.com/bytecodealliance/wasm-micro-runtime/>`_-based WebAssembly runtime.
	// This runtime is not enabled in the official build.
	//
	// .. _extension_envoy.wasm.runtime.wasmtime:
	//
	// **envoy.wasm.runtime.wasmtime**: `Wasmtime <https://wasmtime.dev/>`_-based WebAssembly runtime.
	// This runtime is not enabled in the official build.
	//
	// [#extension-category: envoy.wasm.runtime]
	Runtime string `protobuf:"bytes,2,opt,name=runtime,proto3" json:"runtime,omitempty"`
	// The Wasm code that Envoy will execute.
	Code *v3.AsyncDataSource `protobuf:"bytes,3,opt,name=code,proto3" json:"code,omitempty"`
	// The Wasm configuration used in initialization of a new VM
	// (“proxy_on_start“). “google.protobuf.Struct“ is serialized as JSON before
	// passing it to the plugin. “google.protobuf.BytesValue“ and
	// “google.protobuf.StringValue“ are passed directly without the wrapper.
	Configuration *anypb.Any `protobuf:"bytes,4,opt,name=configuration,proto3" json:"configuration,omitempty"`
	// Allow the wasm file to include pre-compiled code on VMs which support it.
	//
	// .. warning::
	//
	//	This should only be enabled for trusted sources as the precompiled code is not
	//	verified.
	AllowPrecompiled bool `protobuf:"varint,5,opt,name=allow_precompiled,json=allowPrecompiled,proto3" json:"allow_precompiled,omitempty"`
	// If true and the code needs to be remotely fetched and it is not in the cache then NACK the configuration
	// update and do a background fetch to fill the cache, otherwise fetch the code asynchronously and enter
	// warming state.
	NackOnCodeCacheMiss bool `protobuf:"varint,6,opt,name=nack_on_code_cache_miss,json=nackOnCodeCacheMiss,proto3" json:"nack_on_code_cache_miss,omitempty"`
	// Specifies environment variables to be injected to this VM which will be available through
	// WASI's “environ_get“ and “environ_get_sizes“ system calls. Note that these functions
	// are generally called implicitly by your language's standard library. Therefore, you do not
	// need to call them directly. You can access environment variables in the same way you would
	// on native platforms.
	//
	// .. warning::
	//
	//	Envoy rejects the configuration if there's conflict of key space.
	EnvironmentVariables *EnvironmentVariables `protobuf:"bytes,7,opt,name=environment_variables,json=environmentVariables,proto3" json:"environment_variables,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*VmConfig) ProtoMessage() {}

func (x *VmConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_wasm_v3_wasm_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 VmConfig.ProtoReflect.Descriptor instead.
func (*VmConfig) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_wasm_v3_wasm_proto_rawDescGZIP(), []int{3}
}

func (x *VmConfig) GetVmId() string {
	if x != nil {
		return x.VmId
	}
	return ""
}

func (x *VmConfig) GetRuntime() string {
	if x != nil {
		return x.Runtime
	}
	return ""
}

func (x *VmConfig) GetCode() *v3.AsyncDataSource {
	if x != nil {
		return x.Code
	}
	return nil
}

func (x *VmConfig) GetConfiguration() *anypb.Any {
	if x != nil {
		return x.Configuration
	}
	return nil
}

func (x *VmConfig) GetAllowPrecompiled() bool {
	if x != nil {
		return x.AllowPrecompiled
	}
	return false
}

func (x *VmConfig) GetNackOnCodeCacheMiss() bool {
	if x != nil {
		return x.NackOnCodeCacheMiss
	}
	return false
}

func (x *VmConfig) GetEnvironmentVariables() *EnvironmentVariables {
	if x != nil {
		return x.EnvironmentVariables
	}
	return nil
}

type EnvironmentVariables struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The keys of *Envoy's* environment variables exposed to this VM. In other words, if a key exists in Envoy's environment
	// variables, then that key-value pair will be injected. Note that if a key does not exist, it will be ignored.
	HostEnvKeys []string `protobuf:"bytes,1,rep,name=host_env_keys,json=hostEnvKeys,proto3" json:"host_env_keys,omitempty"`
	// Explicitly given key-value pairs to be injected to this VM in the form of "KEY=VALUE".
	KeyValues     map[string]string `protobuf:"bytes,2,rep,name=key_values,json=keyValues,proto3" json:"key_values,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*EnvironmentVariables) ProtoMessage() {}

func (x *EnvironmentVariables) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_wasm_v3_wasm_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 EnvironmentVariables.ProtoReflect.Descriptor instead.
func (*EnvironmentVariables) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_wasm_v3_wasm_proto_rawDescGZIP(), []int{4}
}

func (x *EnvironmentVariables) GetHostEnvKeys() []string {
	if x != nil {
		return x.HostEnvKeys
	}
	return nil
}

func (x *EnvironmentVariables) GetKeyValues() map[string]string {
	if x != nil {
		return x.KeyValues
	}
	return nil
}

// Base Configuration for Wasm Plugins e.g. filters and services.
// [#next-free-field: 10]
type PluginConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A unique name for a filters/services in a VM for use in identifying the filter/service if
	// multiple filters/services are handled by the same “vm_id“ and “root_id“ and for
	// logging/debugging.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// A unique ID for a set of filters/services in a VM which will share a RootContext and Contexts
	// if applicable (e.g. an Wasm HttpFilter and an Wasm AccessLog). If left blank, all
	// filters/services with a blank root_id with the same “vm_id“ will share Context(s).
	RootId string `protobuf:"bytes,2,opt,name=root_id,json=rootId,proto3" json:"root_id,omitempty"`
	// Configuration for finding or starting VM.
	//
	// Types that are valid to be assigned to Vm:
	//
	//	*PluginConfig_VmConfig
	Vm isPluginConfig_Vm `protobuf_oneof:"vm"`
	// Filter/service configuration used to configure or reconfigure a plugin
	// (“proxy_on_configure“).
	// “google.protobuf.Struct“ is serialized as JSON before
	// passing it to the plugin. “google.protobuf.BytesValue“ and
	// “google.protobuf.StringValue“ are passed directly without the wrapper.
	Configuration *anypb.Any `protobuf:"bytes,4,opt,name=configuration,proto3" json:"configuration,omitempty"`
	// If there is a fatal error on the VM (e.g. exception, “abort()“, “on_start“ or “on_configure“ return false),
	// then all plugins associated with the VM will either fail closed (by default), e.g. by returning an HTTP 503 error,
	// or fail open (if 'fail_open' is set to true) by bypassing the filter.
	//
	// .. note::
	//
	//	When ``on_start`` or ``on_configure`` return ``false`` during xDS updates the xDS configuration will be rejected and when ``on_start`` or ``on_configure`` return ``false`` on
	//	initial startup the proxy will not start.
	//
	// This field is deprecated in favor of the “failure_policy“ field.
	//
	// Deprecated: Marked as deprecated in envoy/extensions/wasm/v3/wasm.proto.
	FailOpen bool `protobuf:"varint,5,opt,name=fail_open,json=failOpen,proto3" json:"fail_open,omitempty"`
	// The failure policy for the plugin.
	FailurePolicy FailurePolicy `protobuf:"varint,7,opt,name=failure_policy,json=failurePolicy,proto3,enum=envoy.extensions.wasm.v3.FailurePolicy" json:"failure_policy,omitempty"`
	// Reload configuration. This is only applied when “failure_policy“ is set to “FAIL_RELOAD“.
	ReloadConfig *ReloadConfig `protobuf:"bytes,8,opt,name=reload_config,json=reloadConfig,proto3" json:"reload_config,omitempty"`
	// Configuration for restricting Proxy-Wasm capabilities available to modules.
	CapabilityRestrictionConfig *CapabilityRestrictionConfig `protobuf:"bytes,6,opt,name=capability_restriction_config,json=capabilityRestrictionConfig,proto3" json:"capability_restriction_config,omitempty"`
	// Whether or not to allow plugin onRequestHeaders and onResponseHeaders callbacks to return
	// FilterHeadersStatus::StopIteration.
	AllowOnHeadersStopIteration *wrapperspb.BoolValue `protobuf:"bytes,9,opt,name=allow_on_headers_stop_iteration,json=allowOnHeadersStopIteration,proto3" json:"allow_on_headers_stop_iteration,omitempty"`
	unknownFields               protoimpl.UnknownFields
	sizeCache                   protoimpl.SizeCache
}

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

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

func (*PluginConfig) ProtoMessage() {}

func (x *PluginConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_wasm_v3_wasm_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 PluginConfig.ProtoReflect.Descriptor instead.
func (*PluginConfig) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_wasm_v3_wasm_proto_rawDescGZIP(), []int{5}
}

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

func (x *PluginConfig) GetRootId() string {
	if x != nil {
		return x.RootId
	}
	return ""
}

func (x *PluginConfig) GetVm() isPluginConfig_Vm {
	if x != nil {
		return x.Vm
	}
	return nil
}

func (x *PluginConfig) GetVmConfig() *VmConfig {
	if x != nil {
		if x, ok := x.Vm.(*PluginConfig_VmConfig); ok {
			return x.VmConfig
		}
	}
	return nil
}

func (x *PluginConfig) GetConfiguration() *anypb.Any {
	if x != nil {
		return x.Configuration
	}
	return nil
}

// Deprecated: Marked as deprecated in envoy/extensions/wasm/v3/wasm.proto.
func (x *PluginConfig) GetFailOpen() bool {
	if x != nil {
		return x.FailOpen
	}
	return false
}

func (x *PluginConfig) GetFailurePolicy() FailurePolicy {
	if x != nil {
		return x.FailurePolicy
	}
	return FailurePolicy_UNSPECIFIED
}

func (x *PluginConfig) GetReloadConfig() *ReloadConfig {
	if x != nil {
		return x.ReloadConfig
	}
	return nil
}

func (x *PluginConfig) GetCapabilityRestrictionConfig() *CapabilityRestrictionConfig {
	if x != nil {
		return x.CapabilityRestrictionConfig
	}
	return nil
}

func (x *PluginConfig) GetAllowOnHeadersStopIteration() *wrapperspb.BoolValue {
	if x != nil {
		return x.AllowOnHeadersStopIteration
	}
	return nil
}

type isPluginConfig_Vm interface {
	isPluginConfig_Vm()
}

type PluginConfig_VmConfig struct {
	VmConfig *VmConfig `protobuf:"bytes,3,opt,name=vm_config,json=vmConfig,proto3,oneof"` // TODO: add referential VM configurations.
}

func (*PluginConfig_VmConfig) isPluginConfig_Vm() {}

// WasmService is configured as a built-in “envoy.wasm_service“ :ref:`WasmService
// <config_wasm_service>` This opaque configuration will be used to create a Wasm Service.
type WasmService struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// General plugin configuration.
	Config *PluginConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	// If true, create a single VM rather than creating one VM per worker. Such a singleton can
	// not be used with filters.
	Singleton     bool `protobuf:"varint,2,opt,name=singleton,proto3" json:"singleton,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*WasmService) ProtoMessage() {}

func (x *WasmService) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_wasm_v3_wasm_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 WasmService.ProtoReflect.Descriptor instead.
func (*WasmService) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_wasm_v3_wasm_proto_rawDescGZIP(), []int{6}
}

func (x *WasmService) GetConfig() *PluginConfig {
	if x != nil {
		return x.Config
	}
	return nil
}

func (x *WasmService) GetSingleton() bool {
	if x != nil {
		return x.Singleton
	}
	return false
}

var File_envoy_extensions_wasm_v3_wasm_proto protoreflect.FileDescriptor

const file_envoy_extensions_wasm_v3_wasm_proto_rawDesc = "" +
	"\n" +
	"#envoy/extensions/wasm/v3/wasm.proto\x12\x18envoy.extensions.wasm.v3\x1a\"envoy/config/core/v3/backoff.proto\x1a\x1fenvoy/config/core/v3/base.proto\x1a\x19google/protobuf/any.proto\x1a\x1egoogle/protobuf/wrappers.proto\x1a#envoy/annotations/deprecation.proto\x1a\x1dudpa/annotations/status.proto\"O\n" +
	"\fReloadConfig\x12?\n" +
	"\abackoff\x18\x01 \x01(\v2%.envoy.config.core.v3.BackoffStrategyR\abackoff\"\x97\x02\n" +
	"\x1bCapabilityRestrictionConfig\x12\x81\x01\n" +
	"\x14allowed_capabilities\x18\x01 \x03(\v2N.envoy.extensions.wasm.v3.CapabilityRestrictionConfig.AllowedCapabilitiesEntryR\x13allowedCapabilities\x1at\n" +
	"\x18AllowedCapabilitiesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12B\n" +
	"\x05value\x18\x02 \x01(\v2,.envoy.extensions.wasm.v3.SanitizationConfigR\x05value:\x028\x01\"\x14\n" +
	"\x12SanitizationConfig\"\xf8\x02\n" +
	"\bVmConfig\x12\x13\n" +
	"\x05vm_id\x18\x01 \x01(\tR\x04vmId\x12\x18\n" +
	"\aruntime\x18\x02 \x01(\tR\aruntime\x129\n" +
	"\x04code\x18\x03 \x01(\v2%.envoy.config.core.v3.AsyncDataSourceR\x04code\x12:\n" +
	"\rconfiguration\x18\x04 \x01(\v2\x14.google.protobuf.AnyR\rconfiguration\x12+\n" +
	"\x11allow_precompiled\x18\x05 \x01(\bR\x10allowPrecompiled\x124\n" +
	"\x17nack_on_code_cache_miss\x18\x06 \x01(\bR\x13nackOnCodeCacheMiss\x12c\n" +
	"\x15environment_variables\x18\a \x01(\v2..envoy.extensions.wasm.v3.EnvironmentVariablesR\x14environmentVariables\"\xd6\x01\n" +
	"\x14EnvironmentVariables\x12\"\n" +
	"\rhost_env_keys\x18\x01 \x03(\tR\vhostEnvKeys\x12\\\n" +
	"\n" +
	"key_values\x18\x02 \x03(\v2=.envoy.extensions.wasm.v3.EnvironmentVariables.KeyValuesEntryR\tkeyValues\x1a<\n" +
	"\x0eKeyValuesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xe4\x04\n" +
	"\fPluginConfig\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x17\n" +
	"\aroot_id\x18\x02 \x01(\tR\x06rootId\x12A\n" +
	"\tvm_config\x18\x03 \x01(\v2\".envoy.extensions.wasm.v3.VmConfigH\x00R\bvmConfig\x12:\n" +
	"\rconfiguration\x18\x04 \x01(\v2\x14.google.protobuf.AnyR\rconfiguration\x12(\n" +
	"\tfail_open\x18\x05 \x01(\bB\v\x92ǆ\xd8\x04\x033.0\x18\x01R\bfailOpen\x12N\n" +
	"\x0efailure_policy\x18\a \x01(\x0e2'.envoy.extensions.wasm.v3.FailurePolicyR\rfailurePolicy\x12K\n" +
	"\rreload_config\x18\b \x01(\v2&.envoy.extensions.wasm.v3.ReloadConfigR\freloadConfig\x12y\n" +
	"\x1dcapability_restriction_config\x18\x06 \x01(\v25.envoy.extensions.wasm.v3.CapabilityRestrictionConfigR\x1bcapabilityRestrictionConfig\x12`\n" +
	"\x1fallow_on_headers_stop_iteration\x18\t \x01(\v2\x1a.google.protobuf.BoolValueR\x1ballowOnHeadersStopIterationB\x04\n" +
	"\x02vm\"k\n" +
	"\vWasmService\x12>\n" +
	"\x06config\x18\x01 \x01(\v2&.envoy.extensions.wasm.v3.PluginConfigR\x06config\x12\x1c\n" +
	"\tsingleton\x18\x02 \x01(\bR\tsingleton*Q\n" +
	"\rFailurePolicy\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\x0f\n" +
	"\vFAIL_RELOAD\x10\x01\x12\x0f\n" +
	"\vFAIL_CLOSED\x10\x02\x12\r\n" +
	"\tFAIL_OPEN\x10\x03B\x85\x01\xba\x80\xc8\xd1\x06\x02\x10\x02\n" +
	"&io.envoyproxy.envoy.extensions.wasm.v3B\tWasmProtoP\x01ZFgithub.com/envoyproxy/go-control-plane/envoy/extensions/wasm/v3;wasmv3b\x06proto3"

var (
	file_envoy_extensions_wasm_v3_wasm_proto_rawDescOnce sync.Once
	file_envoy_extensions_wasm_v3_wasm_proto_rawDescData []byte
)

func file_envoy_extensions_wasm_v3_wasm_proto_rawDescGZIP() []byte {
	file_envoy_extensions_wasm_v3_wasm_proto_rawDescOnce.Do(func() {
		file_envoy_extensions_wasm_v3_wasm_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_envoy_extensions_wasm_v3_wasm_proto_rawDesc), len(file_envoy_extensions_wasm_v3_wasm_proto_rawDesc)))
	})
	return file_envoy_extensions_wasm_v3_wasm_proto_rawDescData
}

var file_envoy_extensions_wasm_v3_wasm_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_envoy_extensions_wasm_v3_wasm_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
var file_envoy_extensions_wasm_v3_wasm_proto_goTypes = []any{
	(FailurePolicy)(0),                  // 0: envoy.extensions.wasm.v3.FailurePolicy
	(*ReloadConfig)(nil),                // 1: envoy.extensions.wasm.v3.ReloadConfig
	(*CapabilityRestrictionConfig)(nil), // 2: envoy.extensions.wasm.v3.CapabilityRestrictionConfig
	(*SanitizationConfig)(nil),          // 3: envoy.extensions.wasm.v3.SanitizationConfig
	(*VmConfig)(nil),                    // 4: envoy.extensions.wasm.v3.VmConfig
	(*EnvironmentVariables)(nil),        // 5: envoy.extensions.wasm.v3.EnvironmentVariables
	(*PluginConfig)(nil),                // 6: envoy.extensions.wasm.v3.PluginConfig
	(*WasmService)(nil),                 // 7: envoy.extensions.wasm.v3.WasmService
	nil,                                 // 8: envoy.extensions.wasm.v3.CapabilityRestrictionConfig.AllowedCapabilitiesEntry
	nil,                                 // 9: envoy.extensions.wasm.v3.EnvironmentVariables.KeyValuesEntry
	(*v3.BackoffStrategy)(nil),          // 10: envoy.config.core.v3.BackoffStrategy
	(*v3.AsyncDataSource)(nil),          // 11: envoy.config.core.v3.AsyncDataSource
	(*anypb.Any)(nil),                   // 12: google.protobuf.Any
	(*wrapperspb.BoolValue)(nil),        // 13: google.protobuf.BoolValue
}
var file_envoy_extensions_wasm_v3_wasm_proto_depIdxs = []int32{
	10, // 0: envoy.extensions.wasm.v3.ReloadConfig.backoff:type_name -> envoy.config.core.v3.BackoffStrategy
	8,  // 1: envoy.extensions.wasm.v3.CapabilityRestrictionConfig.allowed_capabilities:type_name -> envoy.extensions.wasm.v3.CapabilityRestrictionConfig.AllowedCapabilitiesEntry
	11, // 2: envoy.extensions.wasm.v3.VmConfig.code:type_name -> envoy.config.core.v3.AsyncDataSource
	12, // 3: envoy.extensions.wasm.v3.VmConfig.configuration:type_name -> google.protobuf.Any
	5,  // 4: envoy.extensions.wasm.v3.VmConfig.environment_variables:type_name -> envoy.extensions.wasm.v3.EnvironmentVariables
	9,  // 5: envoy.extensions.wasm.v3.EnvironmentVariables.key_values:type_name -> envoy.extensions.wasm.v3.EnvironmentVariables.KeyValuesEntry
	4,  // 6: envoy.extensions.wasm.v3.PluginConfig.vm_config:type_name -> envoy.extensions.wasm.v3.VmConfig
	12, // 7: envoy.extensions.wasm.v3.PluginConfig.configuration:type_name -> google.protobuf.Any
	0,  // 8: envoy.extensions.wasm.v3.PluginConfig.failure_policy:type_name -> envoy.extensions.wasm.v3.FailurePolicy
	1,  // 9: envoy.extensions.wasm.v3.PluginConfig.reload_config:type_name -> envoy.extensions.wasm.v3.ReloadConfig
	2,  // 10: envoy.extensions.wasm.v3.PluginConfig.capability_restriction_config:type_name -> envoy.extensions.wasm.v3.CapabilityRestrictionConfig
	13, // 11: envoy.extensions.wasm.v3.PluginConfig.allow_on_headers_stop_iteration:type_name -> google.protobuf.BoolValue
	6,  // 12: envoy.extensions.wasm.v3.WasmService.config:type_name -> envoy.extensions.wasm.v3.PluginConfig
	3,  // 13: envoy.extensions.wasm.v3.CapabilityRestrictionConfig.AllowedCapabilitiesEntry.value:type_name -> envoy.extensions.wasm.v3.SanitizationConfig
	14, // [14:14] is the sub-list for method output_type
	14, // [14:14] is the sub-list for method input_type
	14, // [14:14] is the sub-list for extension type_name
	14, // [14:14] is the sub-list for extension extendee
	0,  // [0:14] is the sub-list for field type_name
}

func init() { file_envoy_extensions_wasm_v3_wasm_proto_init() }
func file_envoy_extensions_wasm_v3_wasm_proto_init() {
	if File_envoy_extensions_wasm_v3_wasm_proto != nil {
		return
	}
	file_envoy_extensions_wasm_v3_wasm_proto_msgTypes[5].OneofWrappers = []any{
		(*PluginConfig_VmConfig)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_envoy_extensions_wasm_v3_wasm_proto_rawDesc), len(file_envoy_extensions_wasm_v3_wasm_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   9,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_envoy_extensions_wasm_v3_wasm_proto_goTypes,
		DependencyIndexes: file_envoy_extensions_wasm_v3_wasm_proto_depIdxs,
		EnumInfos:         file_envoy_extensions_wasm_v3_wasm_proto_enumTypes,
		MessageInfos:      file_envoy_extensions_wasm_v3_wasm_proto_msgTypes,
	}.Build()
	File_envoy_extensions_wasm_v3_wasm_proto = out.File
	file_envoy_extensions_wasm_v3_wasm_proto_goTypes = nil
	file_envoy_extensions_wasm_v3_wasm_proto_depIdxs = nil
}
