}
}

// CSRSign calls Citadel to sign a CSR.
func (c *CitadelClient) CSRSign(csrPEM []byte, certValidTTLInSec int64) (res []string, err error) {
	crMetaStruct := &structpb.Struct{
		Fields: map[string]*structpb.Value{
			security.CertSigner: {
				Kind: &structpb.Value_StringValue{StringValue: c.opts.CertSigner},
			},
		},
	}
	req := &pb.IstioCertificateRequest{
		Csr:              string(csrPEM),

	}
	return buf.String(), nil
}

func ValueString(v *structpb.Value) string {
	switch x := v.Kind.(type) {
	case *structpb.Value_StringValue:
		return x.StringValue
	case *structpb.Value_NumberValue:
		return fmt.Sprint(x.NumberValue)
	default:
		return v.String()
	}
}

func MustStruct(m map[string]any) *structpb.Struct {
	s, _ := structpb.NewStruct(m)
	return s

	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/structpb"

	networking "istio.io/api/networking/v1alpha3"
	"istio.io/istio/pkg/util/protomarshal"
)

// nolint: interfacer
func BuildXDSObjectFromStruct(applyTo networking.EnvoyFilter_ApplyTo, value *structpb.Struct, strict bool) (proto.Message, error) {
	if value == nil {
		// for remove ops
		return nil, nil
	}

type OperatorValues map[string]*structpb.Value

// This regular expression matches list object index selection expression such as
// abc[100], Tba_a[0].
var listObjRex = regexp.MustCompile(`^([a-zA-Z]?[a-z_A-Z\d]*)\[([ ]*[\d]+)[ ]*\]$`)

func getConfigValue(path []string, val map[string]*structpb.Value) *structpb.Value {
	retVal := structpb.NewNullValue()
	if len(path) > 0 {

	// Ensure VIP cluster has services metadata for stats filter usage
	im := getOrCreateIstioMetadata(localCluster.cluster)
	im.Fields["services"] = &structpb.Value{
		Kind: &structpb.Value_ListValue{
			ListValue: &structpb.ListValue{
				Values: []*structpb.Value{},
			},
		},
	}
	svcMetaList := im.Fields["services"].GetListValue()
	svcMetaList.Values = append(svcMetaList.Values, buildServiceMetadata(svc))

var K8SCollection1 = r2.Builder{
	Group:         "testdata.istio.io",
	Kind:          "Kind1",
	Plural:        "Kind1s",
	Version:       "v1alpha1",
	Proto:         "google.protobuf.Struct",
	ReflectType:   reflect.TypeOf(&structpb.Struct{}).Elem(),
	ProtoPackage:  "github.com/gogo/protobuf/types",
	ClusterScoped: false,
	ValidateProto: validation.EmptyValidate,
}.MustBuild()

	}
	// For protobuf types, switch them out with standard types; otherwise we will traverse protobuf internals rather
	// than the standard representation
	if v, ok := node.(*structpb.Struct); ok {
		node = v.AsMap()
	}
	if v, ok := node.(*structpb.Value); ok {
		node = v.AsInterface()
	}
	val := reflect.ValueOf(node)
	kind := reflect.TypeOf(node).Kind()
	var structElems reflect.Value

	switch kind {
	case reflect.Map:

		return util.Errors{err}
	}
	val := &v1alpha1.Values{}
	if err := util.UnmarshalWithJSONPB(string(vs), val, false); err != nil {
		return util.Errors{err}
	}
	return ValuesValidate(DefaultValuesValidations, root.(*structpb.Struct).AsMap(), nil)
}

// ValuesValidate validates the values of the tree using the supplied Func
func ValuesValidate(validations map[string]ValidatorFunc, node any, path util.Path) (errs util.Errors) {
	pstr := path.String()

		}
	}

	return &bootstrap, err
}

func extractMeta(node *model.Node) (*structpb.Struct, error) {
	bytes, err := json.Marshal(node.Metadata)
	if err != nil {
		return nil, err
	}
	rawMeta := map[string]any{}
	if err := json.Unmarshal(bytes, &rawMeta); err != nil {
		return nil, err
	}
	xdsMeta, err := structpb.NewStruct(rawMeta)
	if err != nil {
		return nil, err
	}
	return xdsMeta, nil
}

		return nil
	}
	return out
}

func TypedStructWithFields(typeURL string, fields map[string]interface{}) *anypb.Any {
	value, err := structpb.NewStruct(fields)
	if err != nil {
		log.Error(fmt.Sprintf("error marshaling struct %s: %v", typeURL, err))
	}
	return MessageToAny(&udpa.TypedStruct{
		TypeUrl: typeURL,
		Value:   value,
	})
}

func SilentlyUnmarshalAny[T any](a *anypb.Any) *T {