func Equal(x, y Message) bool {
	return protoV2.Equal(MessageV2(x), MessageV2(y))
}
Equal reports whether two messages are equal.
If two messages marshal to the same bytes under deterministic serialization,
then Equal is guaranteed to report true.

Two messages are equal if they are the same protobuf message type,
have the same set of populated known and extension field values,
and the same set of unknown fields values.

Scalar values are compared with the equivalent of the == operator in Go,
except bytes values which are compared using bytes.Equal and
floating point values which specially treat NaNs as equal.
Message values are compared by recursively calling Equal.
Lists are equal if each element value is also equal.
Maps are equal if they have the same set of keys, where the pair of values
for each key is also equal.
package proto
import (
	protoV2 "google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/reflect/protoreflect"
	"google.golang.org/protobuf/runtime/protoiface"
	"google.golang.org/protobuf/runtime/protoimpl"
)
const (
	ProtoPackageIsVersion1 = true
	ProtoPackageIsVersion2 = true
	ProtoPackageIsVersion3 = true
	ProtoPackageIsVersion4 = true
)
type GeneratedEnum interface{}
type GeneratedMessage interface{}
type Message = protoiface.MessageV1
func MessageV1(m GeneratedMessage) protoiface.MessageV1 {
	return protoimpl.X.ProtoMessageV1Of(m)
}
func MessageV2(m GeneratedMessage) protoV2.Message {
	return protoimpl.X.ProtoMessageV2Of(m)
}
func MessageReflect(m Message) protoreflect.Message {
	return protoimpl.X.MessageOf(m)
}
type Marshaler interface {
	Marshal() ([]byte, error)
}
type Unmarshaler interface {
	Unmarshal([]byte) error
}
type Merger interface {
	Merge(src Message)
}
type RequiredNotSetError struct {
	err error
}
func (e *RequiredNotSetError) Error() string {
	if e.err != nil {
		return e.err.Error()
	}
	return "proto: required field not set"
}
func (e *RequiredNotSetError) RequiredNotSet() bool {
	return true
}
func checkRequiredNotSet(m protoV2.Message) error {
	if err := protoV2.CheckInitialized(m); err != nil {
		return &RequiredNotSetError{err: err}
	}
	return nil
}
func Clone(src Message) Message {
	return MessageV1(protoV2.Clone(MessageV2(src)))
}
func Merge(dst, src Message) {
	protoV2.Merge(MessageV2(dst), MessageV2(src))
}