for _, httpRoute := range vs.GetHttp() {
		for _, match := range httpRoute.GetMatch() {
			for key := range match.GetHeaders() {
				if jwt.ToRoutingClaim(key).Match {
					return key
				}
			}
			for key := range match.GetWithoutHeaders() {
				if jwt.ToRoutingClaim(key).Match {
					return key
				}
			}
		}
	}
	return ""

type Separator int

const (
	Dot Separator = iota
	Square
)

type RoutingClaim struct {
	Match     bool
	Separator Separator
	Claims    []string
}

func ToRoutingClaim(headerName string) RoutingClaim {
	rc := RoutingClaim{}
	if !strings.HasPrefix(strings.ToLower(headerName), HeaderJWTClaim) {
		return rc
	}

	name := headerName[len(HeaderJWTClaim):]

			want: RoutingClaim{Match: true, Separator: Square, Claims: []string{"******@****.***", "key1"}},
		},
	}

	for _, tt := range cases {
		t.Run(tt.name, func(t *testing.T) {
			got := ToRoutingClaim(tt.name)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("want %v, but got %v", tt.want, got)
			}
		})
	}

// - `@request.auth.claims[group][id]` matches the nested claims "group" and "id".
func translateMetadataMatch(name string, in *networking.StringMatch, useExtendedJwt bool) *matcher.MetadataMatcher {
	rc := jwt.ToRoutingClaim(name)
	if !rc.Match {
		return nil
	}
	return authz.MetadataMatcherForJWTClaims(rc.Claims, util.ConvertToEnvoyMatch(in), useExtendedJwt)
}

// translateHeaderMatch translates to HeaderMatcher

func ValidateHTTPHeaderNameOrJwtClaimRoute(name string) error {
	if name == "" {
		return fmt.Errorf("header name cannot be empty")
	}
	if jwt.ToRoutingClaim(name).Match {
		// Jwt claim form
		return nil
	}
	// Else ensure its a valid header
	if !validHeaderRegex.MatchString(name) {
		return fmt.Errorf("header name %s is not a valid header name", name)
	}