transformation

type Extraction struct {

	// The source of the extraction
	//
	// Types that are assignable to Source:
	//
	//	*Extraction_Header
	//	*Extraction_Body
	Source isExtraction_Source `protobuf_oneof:"source"`
	// The regex field specifies the regular expression used for matching against the source content.
	//   - In EXTRACT mode, the entire source must match the regex. `subgroup` selects the n-th capturing group,
	//     which determines the part of the match that you want to extract. If the regex does not match the source,
	//     the result of the extraction will be an empty value.
	//   - In SINGLE_REPLACE mode, the regex also needs to match the entire source. `subgroup` selects the n-th capturing group
	//     that is replaced with the content of `replacement_text`. If the regex does not match the source, the result
	//     of the replacement will be the source itself.
	//   - In REPLACE_ALL mode, the regex is applied repeatedly to find all occurrences within the source that match.
	//     Each matching occurrence is replaced with the value in `replacement_text`. In this mode, the configuration is rejected
	//     if `subgroup` is set. If the regex does not match the source, the result of the replacement will be the source itself.
	Regex string `protobuf:"bytes,2,opt,name=regex,proto3" json:"regex,omitempty"`
	// If your regex contains capturing groups, use this field to determine the
	// group that you want to select. Defaults to 0.
	// If set in `EXTRACT` and `SINGLE_REPLACE` modes, the subgroup represents the capturing
	// group that you want to extract or replace in the source.
	// The configuration is rejected if you set subgroup to a non-zero value when using thev `REPLACE_ALL` mode.
	Subgroup uint32 `protobuf:"varint,3,opt,name=subgroup,proto3" json:"subgroup,omitempty"`
	// The value `replacement_text` is used to format the substitution for matched sequences in
	// in an input string. This value is only legal in `SINGLE_REPLACE` and `REPLACE_ALL` modes.
	// - In `SINGLE_REPLACE` mode, the `subgroup` selects the n-th capturing group, which represents
	// the value that you want to replace with the string provided in `replacement_text`.
	// - In `REPLACE_ALL` mode, each sequence that matches the specified regex in the input is
	// replaced with the value in`replacement_text`.
	//
	//	The `replacement_text` can include special syntax, such as $1, $2, etc., to refer to
	//
	// capturing groups within the regular expression.
	//
	//	The value that is specified in `replacement_text` is treated as a string, and is passed
	//
	// to `std::regex_replace` as the replacement string.
	//
	//	For more informatino, see https://en.cppreference.com/w/cpp/regex/regex_replace.
	ReplacementText *wrappers.StringValue `protobuf:"bytes,5,opt,name=replacement_text,json=replacementText,proto3" json:"replacement_text,omitempty"`
	// The mode of operation for the extraction.
	// Defaults to EXTRACT.
	Mode Extraction_Mode `protobuf:"varint,6,opt,name=mode,proto3,enum=envoy.api.v2.filter.http.Extraction_Mode" json:"mode,omitempty"`
	// contains filtered or unexported fields
}

type Extraction_Body struct {
	// Extract information from the request/response body
	Body *empty.Empty `protobuf:"bytes,4,opt,name=body,proto3,oneof"`
}

type Extraction_Header struct {
	// Extract information from headers
	Header string `protobuf:"bytes,1,opt,name=header,proto3,oneof"`
}

type Extraction_Mode int32

type FilterTransformations struct {

	// Specifies transformations based on the route matches. The first matched
	// transformation will be applied. If there are overlapped match conditions,
	// please put the most specific match first.
	Transformations []*TransformationRule `protobuf:"bytes,1,rep,name=transformations,proto3" json:"transformations,omitempty"`
	// Only RouteTransformations.RouteTransformation with matching stage will be
	// used with this filter.
	Stage uint32 `protobuf:"varint,2,opt,name=stage,proto3" json:"stage,omitempty"`
	// Logs request/response sensitive information
	// By default, this is false so no request or response sensitive information is logged.
	// If set to true, the filter will log the request/response body and headers before and
	// after any transformation is applied.
	LogRequestResponseInfo bool `` /* 132-byte string literal not displayed */
	// contains filtered or unexported fields
}

type HeaderBodyTransform struct {

	// When transforming a request, setting this to true will additionally add "queryString",
	// "queryStringParameters", "multiValueQueryStringParameters", "httpMethod", "path",
	// and "multiValueHeaders" to the body
	AddRequestMetadata bool `protobuf:"varint,1,opt,name=add_request_metadata,json=addRequestMetadata,proto3" json:"add_request_metadata,omitempty"`
	// contains filtered or unexported fields
}

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

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

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

type ResponseMatcher struct {

	// Specifies a set of headers that the route should match on. The router will
	// check the response headers against all the specified headers in the route
	// config. A match will happen if all the headers in the route are present in
	// the request with the same values (or based on presence if the value field
	// is not in the config).
	Headers []*v3.HeaderMatcher `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty"`
	// Only match responses with non empty response code details (this usually
	// implies a local reply).
	ResponseCodeDetails *v31.StringMatcher `protobuf:"bytes,2,opt,name=response_code_details,json=responseCodeDetails,proto3" json:"response_code_details,omitempty"`
	// contains filtered or unexported fields
}

type ResponseTransformationRule struct {
	Match *ResponseMatcher `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
	// transformation to perform
	ResponseTransformation *Transformation `` /* 127-byte string literal not displayed */
	// contains filtered or unexported fields
}

type RouteTransformations struct {

	// deprecated. Use transformations[].request_match.request_transformation
	// instead.
	//
	// Deprecated: Marked as deprecated in github.com/solo-io/gloo/projects/gloo/api/external/envoy/extensions/transformation/transformation.proto.
	RequestTransformation *Transformation `protobuf:"bytes,1,opt,name=request_transformation,json=requestTransformation,proto3" json:"request_transformation,omitempty"`
	// deprecated. Use transformations[].request_match.response_transformation
	// instead.
	//
	// Deprecated: Marked as deprecated in github.com/solo-io/gloo/projects/gloo/api/external/envoy/extensions/transformation/transformation.proto.
	ResponseTransformation *Transformation `` /* 127-byte string literal not displayed */
	// deprecated. Use transformations[].request_match.clear_route_cache instead.
	//
	// Deprecated: Marked as deprecated in github.com/solo-io/gloo/projects/gloo/api/external/envoy/extensions/transformation/transformation.proto.
	ClearRouteCache bool                                        `protobuf:"varint,3,opt,name=clear_route_cache,json=clearRouteCache,proto3" json:"clear_route_cache,omitempty"`
	Transformations []*RouteTransformations_RouteTransformation `protobuf:"bytes,4,rep,name=transformations,proto3" json:"transformations,omitempty"`
	// contains filtered or unexported fields
}

type RouteTransformations_RouteTransformation struct {

	// Stage number. This transformation will only be processed by filters with
	// the same stage number.
	Stage uint32 `protobuf:"varint,1,opt,name=stage,proto3" json:"stage,omitempty"`
	// Types that are assignable to Match:
	//
	//	*RouteTransformations_RouteTransformation_RequestMatch_
	//	*RouteTransformations_RouteTransformation_ResponseMatch_
	Match isRouteTransformations_RouteTransformation_Match `protobuf_oneof:"match"`
	// contains filtered or unexported fields
}

type RouteTransformations_RouteTransformation_RequestMatch struct {

	// if no match is specified, will match all
	Match *v3.RouteMatch `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
	// transformation to perform
	RequestTransformation  *Transformation `protobuf:"bytes,2,opt,name=request_transformation,json=requestTransformation,proto3" json:"request_transformation,omitempty"`
	ResponseTransformation *Transformation `` /* 127-byte string literal not displayed */
	// clear the route cache if the request transformation was applied
	ClearRouteCache bool `protobuf:"varint,4,opt,name=clear_route_cache,json=clearRouteCache,proto3" json:"clear_route_cache,omitempty"`
	// contains filtered or unexported fields
}

type RouteTransformations_RouteTransformation_RequestMatch_ struct {
	RequestMatch *RouteTransformations_RouteTransformation_RequestMatch `protobuf:"bytes,2,opt,name=request_match,json=requestMatch,proto3,oneof"`
}

type RouteTransformations_RouteTransformation_ResponseMatch struct {
	Match *ResponseMatcher `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
	// transformation to perform
	ResponseTransformation *Transformation `` /* 127-byte string literal not displayed */
	// contains filtered or unexported fields
}

type RouteTransformations_RouteTransformation_ResponseMatch_ struct {
	ResponseMatch *RouteTransformations_RouteTransformation_ResponseMatch `protobuf:"bytes,3,opt,name=response_match,json=responseMatch,proto3,oneof"`
}

type Transformation struct {

	// The type of transformation to apply.
	//
	// Types that are assignable to TransformationType:
	//
	//	*Transformation_TransformationTemplate
	//	*Transformation_HeaderBodyTransform
	//	*Transformation_TransformerConfig
	TransformationType isTransformation_TransformationType `protobuf_oneof:"transformation_type"`
	// Logs request/response sensitive information
	// By default, this is false so no request or response sensitive information is logged.
	// If set to true, the filter will log the request/response body and headers before and
	// after this transformation is applied.
	LogRequestResponseInfo *wrappers.BoolValue `` /* 131-byte string literal not displayed */
	// contains filtered or unexported fields
}

type TransformationRule struct {

	// The route matching parameter. Only when the match is satisfied, the
	// "requires" field will apply.
	//
	// For example: following match will match all requests.
	//
	// .. code-block:: yaml
	//
	//	match:
	//	  prefix: /
	Match *v3.RouteMatch `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
	// transformation to perform
	RouteTransformations *TransformationRule_Transformations `protobuf:"bytes,2,opt,name=route_transformations,json=routeTransformations,proto3" json:"route_transformations,omitempty"`
	// contains filtered or unexported fields
}

type TransformationRule_Transformations struct {

	// Apply a transformation to requests.
	RequestTransformation *Transformation `protobuf:"bytes,1,opt,name=request_transformation,json=requestTransformation,proto3" json:"request_transformation,omitempty"`
	// Clear the route cache if the request transformation was applied.
	ClearRouteCache bool `protobuf:"varint,3,opt,name=clear_route_cache,json=clearRouteCache,proto3" json:"clear_route_cache,omitempty"`
	// Apply a transformation to responses.
	ResponseTransformation *Transformation `` /* 127-byte string literal not displayed */
	// Apply a transformation in the onStreamComplete callback
	// (for modifying headers and dynamic metadata for access logs)
	OnStreamCompletionTransformation *Transformation `` /* 161-byte string literal not displayed */
	// contains filtered or unexported fields
}

type TransformationTemplate struct {

	// If set to true, use JSON pointer notation (e.g. "time/start") instead of
	// dot notation (e.g. "time.start") to access JSON elements. Defaults to
	// false.
	//
	// Please note that, if set to 'true', you will need to use the `extraction`
	// function to access extractors in the template (e.g. '{{
	// extraction("my_extractor") }}'); if the default value of 'false' is used,
	// extractors will simply be available by their name (e.g. '{{ my_extractor
	// }}').
	AdvancedTemplates bool `protobuf:"varint,1,opt,name=advanced_templates,json=advancedTemplates,proto3" json:"advanced_templates,omitempty"`
	// Use this attribute to extract information from the request. It consists of
	// a map of strings to extractors. The extractor will defines which
	// information will be extracted, while the string key will provide the
	// extractor with a name. You can reference extractors by their name in
	// templates, e.g. "{{ my-extractor }}" will render to the value of the
	// "my-extractor" extractor.
	Extractors map[string]*Extraction `` /* 161-byte string literal not displayed */
	// Use this attribute to transform request/response headers. It consists of a
	// map of strings to templates. The string key determines the name of the
	// resulting header, the rendered template will determine the value. Any existing
	// headers with the same header name will be replaced by the transformed header.
	// If a header name is included in `headers` and `headers_to_append`, it will first
	// be replaced the template in `headers`, then additional header values will be appended
	// by the templates defined in `headers_to_append`.
	// For example, the following header transformation configuration:
	//
	// “`yaml
	//
	//	headers:
	//	  x-header-one: {"text": "first {{inja}} template"}
	//	  x-header-one: {"text": "second {{inja}} template"}
	//	headersToAppend:
	//	  - key: x-header-one
	//	    value: {"text": "first appended {{inja}} template"}
	//	  - key: x-header-one
	//	    value: {"text": "second appended {{inja}} template"}
	//
	// “`
	// will result in the following headers on the HTTP message:
	//
	// “`
	// x-header-one: first inja template
	// x-header-one: first appended inja template
	// x-header-one: second appended inja template
	// “`
	Headers map[string]*InjaTemplate `` /* 155-byte string literal not displayed */
	// Use this attribute to transform request/response headers. It consists of
	// an array of string/template objects. Use this attribute to define multiple
	// templates for a single header. Header template(s) defined here will be appended to any
	// existing headers with the same header name, not replace existing ones.
	// See `headers` documentation to see an example of usage.
	HeadersToAppend []*TransformationTemplate_HeaderToAppend `protobuf:"bytes,10,rep,name=headers_to_append,json=headersToAppend,proto3" json:"headers_to_append,omitempty"`
	// Attribute to remove headers from requests. If a header is present multiple
	// times, all instances of the header will be removed.
	HeadersToRemove []string `protobuf:"bytes,11,rep,name=headers_to_remove,json=headersToRemove,proto3" json:"headers_to_remove,omitempty"`
	// Determines the type of transformation to apply to the request/response body
	//
	// Types that are assignable to BodyTransformation:
	//
	//	*TransformationTemplate_Body
	//	*TransformationTemplate_Passthrough
	//	*TransformationTemplate_MergeExtractorsToBody
	BodyTransformation isTransformationTemplate_BodyTransformation `protobuf_oneof:"body_transformation"`
	// Determines how the body will be parsed. Defaults to ParseAsJson
	ParseBodyBehavior TransformationTemplate_RequestBodyParse `` /* 185-byte string literal not displayed */
	// If set to true, Envoy will not throw an exception in case the body parsing
	// fails.
	IgnoreErrorOnParse bool `protobuf:"varint,8,opt,name=ignore_error_on_parse,json=ignoreErrorOnParse,proto3" json:"ignore_error_on_parse,omitempty"`
	// Use this field to set Dynamic Metadata.
	DynamicMetadataValues []*TransformationTemplate_DynamicMetadataValue `` /* 126-byte string literal not displayed */
	// Use this field to set Inja behavior when rendering strings which contain
	// characters that would need to be escaped to be valid JSON. Note that this
	// sets the behavior for the entire transformation. Use raw_strings function
	// for fine-grained control within a template.
	EscapeCharacters bool `protobuf:"varint,12,opt,name=escape_characters,json=escapeCharacters,proto3" json:"escape_characters,omitempty"`
	// contains filtered or unexported fields
}

type TransformationTemplate_Body struct {
	// Apply a template to the body
	Body *InjaTemplate `protobuf:"bytes,4,opt,name=body,proto3,oneof"`
}

type TransformationTemplate_DynamicMetadataValue struct {

	// The metadata namespace. Defaults to the filter namespace.
	MetadataNamespace string `protobuf:"bytes,1,opt,name=metadata_namespace,json=metadataNamespace,proto3" json:"metadata_namespace,omitempty"`
	// The metadata key.
	Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	// A template that determines the metadata value.
	Value *InjaTemplate `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type TransformationTemplate_HeaderToAppend struct {

	// Header name
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// Apply a template to the header value
	Value *InjaTemplate `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type TransformationTemplate_MergeExtractorsToBody struct {
	// Merge all defined extractors to the request/response body.
	// If you want to nest elements inside the body, use dot separator in the
	// extractor name.
	MergeExtractorsToBody *MergeExtractorsToBody `protobuf:"bytes,6,opt,name=merge_extractors_to_body,json=mergeExtractorsToBody,proto3,oneof"`
}

type TransformationTemplate_Passthrough struct {
	// This will cause the transformation filter not to buffer the body.
	// Use this setting if the response body is large and you don't need to
	// transform nor extract information from it.
	Passthrough *Passthrough `protobuf:"bytes,5,opt,name=passthrough,proto3,oneof"`
}

type TransformationTemplate_RequestBodyParse int32

type Transformation_HeaderBodyTransform struct {
	// This type of transformation will make all the headers available in the
	// response body. The resulting JSON body will consist of two attributes:
	// 'headers', containing the headers, and 'body', containing the original
	// body.
	HeaderBodyTransform *HeaderBodyTransform `protobuf:"bytes,2,opt,name=header_body_transform,json=headerBodyTransform,proto3,oneof"`
}

type Transformation_TransformationTemplate struct {
	// Apply transformation templates.
	TransformationTemplate *TransformationTemplate `protobuf:"bytes,1,opt,name=transformation_template,json=transformationTemplate,proto3,oneof"`
}

type Transformation_TransformerConfig struct {
	// Configuration for an externally implemented transformer, used by
	// envoy transformation filter.
	TransformerConfig *v32.TypedExtensionConfig `protobuf:"bytes,3,opt,name=transformer_config,json=transformerConfig,proto3,oneof"`
}