package proto

Import Path
	github.com/gogo/protobuf/proto (on go.dev)

Dependency Relation
	imports 18 packages, and imported by 3 packages

Involved Source Files

	    clone.go
	    custom_gogo.go
	    decode.go
	    deprecated.go
	    discard.go
	    duration.go
	    duration_gogo.go
	    encode.go
	    encode_gogo.go
	    equal.go
	    extensions.go
	    extensions_gogo.go
	  d lib.go
		Package proto converts data structures to and from the wire format of
		protocol buffers.  It works in concert with the Go source code generated
		for .proto files by the protocol compiler.
		
		A summary of the properties of the protocol buffer interface
		for a protocol buffer variable v:
		
		  - Names are turned from camel_case to CamelCase for export.
		  - There are no methods on v to set fields; just treat
			them as structure fields.
		  - There are getters that return a field's value if set,
			and return the field's default value if unset.
			The getters work even if the receiver is a nil message.
		  - The zero value for a struct is its correct initialization state.
			All desired fields must be set before marshaling.
		  - A Reset() method will restore a protobuf struct to its zero state.
		  - Non-repeated fields are pointers to the values; nil means unset.
			That is, optional or required field int32 f becomes F *int32.
		  - Repeated fields are slices.
		  - Helper functions are available to aid the setting of fields.
			msg.Foo = proto.String("hello") // set field
		  - Constants are defined to hold the default values of all fields that
			have them.  They have the form Default_StructName_FieldName.
			Because the getter methods handle defaulted values,
			direct use of these constants should be rare.
		  - Enums are given type names and maps from names to values.
			Enum values are prefixed by the enclosing message's name, or by the
			enum's type name if it is a top-level enum. Enum types have a String
			method, and a Enum method to assist in message construction.
		  - Nested messages, groups and enums have type names prefixed with the name of
			the surrounding message type.
		  - Extensions are given descriptor names that start with E_,
			followed by an underscore-delimited list of the nested messages
			that contain it (if any) followed by the CamelCased name of the
			extension field itself.  HasExtension, ClearExtension, GetExtension
			and SetExtension are functions for manipulating extensions.
		  - Oneof field sets are given a single field in their message,
			with distinguished wrapper types for each possible field value.
		  - Marshal and Unmarshal are functions to encode and decode the wire format.
		
		When the .proto file specifies `syntax="proto3"`, there are some differences:
		
		  - Non-repeated fields of non-message type are values instead of pointers.
		  - Enum types do not get an Enum method.
		
		The simplest way to describe this is to see an example.
		Given file test.proto, containing
		
			package example;
		
			enum FOO { X = 17; }
		
			message Test {
			  required string label = 1;
			  optional int32 type = 2 [default=77];
			  repeated int64 reps = 3;
			  optional group OptionalGroup = 4 {
			    required string RequiredField = 5;
			  }
			  oneof union {
			    int32 number = 6;
			    string name = 7;
			  }
			}
		
		The resulting file, test.pb.go, is:
		
			package example
		
			import proto "github.com/gogo/protobuf/proto"
			import math "math"
		
			type FOO int32
			const (
				FOO_X FOO = 17
			)
			var FOO_name = map[int32]string{
				17: "X",
			}
			var FOO_value = map[string]int32{
				"X": 17,
			}
		
			func (x FOO) Enum() *FOO {
				p := new(FOO)
				*p = x
				return p
			}
			func (x FOO) String() string {
				return proto.EnumName(FOO_name, int32(x))
			}
			func (x *FOO) UnmarshalJSON(data []byte) error {
				value, err := proto.UnmarshalJSONEnum(FOO_value, data)
				if err != nil {
					return err
				}
				*x = FOO(value)
				return nil
			}
		
			type Test struct {
				Label         *string             `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
				Type          *int32              `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
				Reps          []int64             `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
				Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
				// Types that are valid to be assigned to Union:
				//	*Test_Number
				//	*Test_Name
				Union            isTest_Union `protobuf_oneof:"union"`
				XXX_unrecognized []byte       `json:"-"`
			}
			func (m *Test) Reset()         { *m = Test{} }
			func (m *Test) String() string { return proto.CompactTextString(m) }
			func (*Test) ProtoMessage() {}
		
			type isTest_Union interface {
				isTest_Union()
			}
		
			type Test_Number struct {
				Number int32 `protobuf:"varint,6,opt,name=number"`
			}
			type Test_Name struct {
				Name string `protobuf:"bytes,7,opt,name=name"`
			}
		
			func (*Test_Number) isTest_Union() {}
			func (*Test_Name) isTest_Union()   {}
		
			func (m *Test) GetUnion() isTest_Union {
				if m != nil {
					return m.Union
				}
				return nil
			}
			const Default_Test_Type int32 = 77
		
			func (m *Test) GetLabel() string {
				if m != nil && m.Label != nil {
					return *m.Label
				}
				return ""
			}
		
			func (m *Test) GetType() int32 {
				if m != nil && m.Type != nil {
					return *m.Type
				}
				return Default_Test_Type
			}
		
			func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
				if m != nil {
					return m.Optionalgroup
				}
				return nil
			}
		
			type Test_OptionalGroup struct {
				RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
			}
			func (m *Test_OptionalGroup) Reset()         { *m = Test_OptionalGroup{} }
			func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
		
			func (m *Test_OptionalGroup) GetRequiredField() string {
				if m != nil && m.RequiredField != nil {
					return *m.RequiredField
				}
				return ""
			}
		
			func (m *Test) GetNumber() int32 {
				if x, ok := m.GetUnion().(*Test_Number); ok {
					return x.Number
				}
				return 0
			}
		
			func (m *Test) GetName() string {
				if x, ok := m.GetUnion().(*Test_Name); ok {
					return x.Name
				}
				return ""
			}
		
			func init() {
				proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
			}
		
		To create and play with a Test object:
		
			package main
		
			import (
				"log"
		
				"github.com/gogo/protobuf/proto"
				pb "./example.pb"
			)
		
			func main() {
				test := &pb.Test{
					Label: proto.String("hello"),
					Type:  proto.Int32(17),
					Reps:  []int64{1, 2, 3},
					Optionalgroup: &pb.Test_OptionalGroup{
						RequiredField: proto.String("good bye"),
					},
					Union: &pb.Test_Name{"fred"},
				}
				data, err := proto.Marshal(test)
				if err != nil {
					log.Fatal("marshaling error: ", err)
				}
				newTest := &pb.Test{}
				err = proto.Unmarshal(data, newTest)
				if err != nil {
					log.Fatal("unmarshaling error: ", err)
				}
				// Now test and newTest contain the same data.
				if test.GetLabel() != newTest.GetLabel() {
					log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
				}
				// Use a type switch to determine which oneof was set.
				switch u := test.Union.(type) {
				case *pb.Test_Number: // u.Number contains the number.
				case *pb.Test_Name: // u.Name contains the string.
				}
				// etc.
			}

	    lib_gogo.go
	    message_set.go
	    pointer_unsafe.go
	    pointer_unsafe_gogo.go
	    properties.go
	    properties_gogo.go
	    skip_gogo.go
	    table_marshal.go
	    table_marshal_gogo.go
	    table_merge.go
	    table_unmarshal.go
	    table_unmarshal_gogo.go
	    text.go
	    text_gogo.go
	    text_parser.go
	    timestamp.go
	    timestamp_gogo.go
	    wrappers.go
	    wrappers_gogo.go
Package-Level Type Names (total 19)

	/* sort by: alphabet | popularity */
	 type Buffer (struct)
		A Buffer is a buffer manager for marshaling and unmarshaling
		protocol buffers.  It may be reused between invocations to
		reduce memory usage.  It is not necessary to use a Buffer;
		the global functions Marshal and Unmarshal create a
		temporary Buffer and are fine for most applications.

		Methods (total 24)
			(*Buffer) Bytes() []byte
				Bytes returns the contents of the Buffer.

			(*Buffer) DebugPrint(s string, b []byte)
				DebugPrint dumps the encoded data in b in a debugging format with a header
				including the string s. Used in testing but made available for general debugging.

			(*Buffer) DecodeFixed32() (x uint64, err error)
				DecodeFixed32 reads a 32-bit integer from the Buffer.
				This is the format for the
				fixed32, sfixed32, and float protocol buffer types.

			(*Buffer) DecodeFixed64() (x uint64, err error)
				DecodeFixed64 reads a 64-bit integer from the Buffer.
				This is the format for the
				fixed64, sfixed64, and double protocol buffer types.

			(*Buffer) DecodeGroup(pb Message) error
				DecodeGroup reads a tag-delimited group from the Buffer.
				StartGroup tag is already consumed. This function consumes
				EndGroup tag.

			(*Buffer) DecodeMessage(pb Message) error
				DecodeMessage reads a count-delimited message from the Buffer.

			(*Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error)
				DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
				This is the format used for the bytes protocol buffer
				type and for embedded messages.

			(*Buffer) DecodeStringBytes() (s string, err error)
				DecodeStringBytes reads an encoded string from the Buffer.
				This is the format used for the proto2 string type.

			(*Buffer) DecodeVarint() (x uint64, err error)
				DecodeVarint reads a varint-encoded integer from the Buffer.
				This is the format for the
				int32, int64, uint32, uint64, bool, and enum
				protocol buffer types.

			(*Buffer) DecodeZigzag32() (x uint64, err error)
				DecodeZigzag32 reads a zigzag-encoded 32-bit integer
				from  the Buffer.
				This is the format used for the sint32 protocol buffer type.

			(*Buffer) DecodeZigzag64() (x uint64, err error)
				DecodeZigzag64 reads a zigzag-encoded 64-bit integer
				from the Buffer.
				This is the format used for the sint64 protocol buffer type.

			(*Buffer) EncodeFixed32(x uint64) error
				EncodeFixed32 writes a 32-bit integer to the Buffer.
				This is the format for the
				fixed32, sfixed32, and float protocol buffer types.

			(*Buffer) EncodeFixed64(x uint64) error
				EncodeFixed64 writes a 64-bit integer to the Buffer.
				This is the format for the
				fixed64, sfixed64, and double protocol buffer types.

			(*Buffer) EncodeMessage(pb Message) error
				EncodeMessage writes the protocol buffer to the Buffer,
				prefixed by a varint-encoded length.

			(*Buffer) EncodeRawBytes(b []byte) error
				EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
				This is the format used for the bytes protocol buffer
				type and for embedded messages.

			(*Buffer) EncodeStringBytes(s string) error
				EncodeStringBytes writes an encoded string to the Buffer.
				This is the format used for the proto2 string type.

			(*Buffer) EncodeVarint(x uint64) error
				EncodeVarint writes a varint-encoded integer to the Buffer.
				This is the format for the
				int32, int64, uint32, uint64, bool, and enum
				protocol buffer types.

			(*Buffer) EncodeZigzag32(x uint64) error
				EncodeZigzag32 writes a zigzag-encoded 32-bit integer
				to the Buffer.
				This is the format used for the sint32 protocol buffer type.

			(*Buffer) EncodeZigzag64(x uint64) error
				EncodeZigzag64 writes a zigzag-encoded 64-bit integer
				to the Buffer.
				This is the format used for the sint64 protocol buffer type.

			(*Buffer) Marshal(pb Message) error
				Marshal takes a protocol buffer message
				and encodes it into the wire format, writing the result to the
				Buffer.
				This is an alternative entry point. It is not necessary to use
				a Buffer for most applications.

			(*Buffer) Reset()
				Reset resets the Buffer, ready for marshaling a new protocol buffer.

			(*Buffer) SetBuf(s []byte)
				SetBuf replaces the internal buffer with the slice,
				ready for unmarshaling the contents of the slice.

			(*Buffer) SetDeterministic(deterministic bool)
				SetDeterministic sets whether to use deterministic serialization.
				
				Deterministic serialization guarantees that for a given binary, equal
				messages will always be serialized to the same bytes. This implies:
				
				  - Repeated serialization of a message will return the same bytes.
				  - Different processes of the same binary (which may be executing on
				    different machines) will serialize equal messages to the same bytes.
				
				Note that the deterministic serialization is NOT canonical across
				languages. It is not guaranteed to remain stable over time. It is unstable
				across different builds with schema changes due to unknown fields.
				Users who need canonical serialization (e.g., persistent storage in a
				canonical form, fingerprinting, etc.) should define their own
				canonicalization specification and implement their own serializer rather
				than relying on this API.
				
				If deterministic serialization is requested, map entries will be sorted
				by keys in lexographical order. This is an implementation detail and
				subject to change.

			(*Buffer) Unmarshal(pb Message) error
				Unmarshal parses the protocol buffer representation in the
				Buffer and places the decoded result in pb.  If the struct
				underlying pb does not match the data in the buffer, the results can be
				unpredictable.
				
				Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.

		Implements (at least one exported)
			*Buffer : github.com/apache/arrow-go/v18/internal/hashing.ByteSlice
		As Outputs Of (at least one exported)
			func NewBuffer(e []byte) *Buffer

	 type Extension (struct)
		Extension represents an extension in a message.

		Methods (total 4)
			(*Extension) Compare(that *Extension) int
			(*Extension) Encode() error
			(*Extension) Equal(that *Extension) bool
			( Extension) GoString() string
		Implements (at least one exported)
			 Extension : fmt.GoStringer
		As Outputs Of (at least 3)
			func BytesToExtensionsMap(buf []byte) (map[int32]Extension, error)
			func GetUnsafeExtensionsMap(extendable Message) map[int32]Extension
			func NewExtension(e []byte) Extension
		As Inputs Of (at least 7)
			func EncodeExtensionMap(m map[int32]Extension, data []byte) (n int, err error)
			func EncodeExtensionMapBackwards(m map[int32]Extension, data []byte) (n int, err error)
			func GetRawExtension(m map[int32]Extension, id int32) ([]byte, error)
			func NewUnsafeXXX_InternalExtensions(m map[int32]Extension) XXX_InternalExtensions
			func StringFromExtensionsMap(m map[int32]Extension) string
			func (*Extension).Compare(that *Extension) int
			func (*Extension).Equal(that *Extension) bool

	 type ExtensionDesc (struct)
		ExtensionDesc represents an extension specification.
		Used in generated code from the protocol compiler.

		Fields (total 6)
			ExtendedType Message
				// nil pointer to the type that is being extended

			ExtensionType interface{}
				// nil pointer to the extension type

			Field int32
				// field number

			Filename string
				// name of the file in which the extension is defined

			Name string
				// fully-qualified name of extension, for text formatting

			Tag string
				// protobuf tag style

		As Outputs Of (at least 2)
			func ExtensionDescs(pb Message) ([]*ExtensionDesc, error)
			func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc
		As Inputs Of (at least 7)
			func ClearExtension(pb Message, extension *ExtensionDesc)
			func GetBoolExtension(pb Message, extension *ExtensionDesc, ifnotset bool) bool
			func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error)
			func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error)
			func HasExtension(pb Message, extension *ExtensionDesc) bool
			func RegisterExtension(desc *ExtensionDesc)
			func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error

	 type ExtensionRange (struct)
		ExtensionRange represents a range of message extensions for a protocol buffer.
		Used in code generated by the protocol compiler.

		Fields (total 2)
			End int32
				// both inclusive

			Start int32
				// both inclusive


	 type InternalMessageInfo (struct)
		InternalMessageInfo is a type used internally by generated .pb.go files.
		This type is not intended to be used by non-generated code.
		This type is not subject to any compatibility guarantee.

		Methods (total 5)
			(*InternalMessageInfo) DiscardUnknown(m Message)
				DiscardUnknown recursively discards all unknown fields.

			(*InternalMessageInfo) Marshal(b []byte, msg Message, deterministic bool) ([]byte, error)
				Marshal is the entry point from generated code,
				and should be ONLY called by generated code.
				It marshals msg to the end of b.
				a is a pointer to a place to store cached marshal info.

			(*InternalMessageInfo) Merge(dst, src Message)
				Merge merges the src message into dst.
				This assumes that dst and src of the same type and are non-nil.

			(*InternalMessageInfo) Size(msg Message) int
				Size is the entry point from generated code,
				and should be ONLY called by generated code.
				It computes the size of encoded data of msg.
				a is a pointer to a place to store cached marshal info.

			(*InternalMessageInfo) Unmarshal(msg Message, b []byte) error
				Unmarshal is the entry point from the generated .pb.go files.
				This function is not intended to be used by non-generated code.
				This function is not subject to any compatibility guarantee.
				msg contains a pointer to a protocol buffer struct.
				b is the data to be unmarshaled into the protocol buffer.
				a is a pointer to a place to store cached unmarshal information.


	 type Marshaler (interface)
		Marshaler is the interface representing objects that can marshal themselves.

		Methods (only one)
			( Marshaler) Marshal() ([]byte, error)
		Implemented By (at least 152)
			 github.com/golang/protobuf/proto.Marshaler (interface)
			 github.com/libp2p/go-libp2p/core/peer.ID
			*github.com/libp2p/go-libp2p/core/record.Envelope
			 github.com/libp2p/go-libp2p-pubsub.Message
			*github.com/libp2p/go-libp2p-pubsub.RPC
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlGraft
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIDontWant
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIHave
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIWant
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlPrune
			*github.com/libp2p/go-libp2p-pubsub/pb.Message
			*github.com/libp2p/go-libp2p-pubsub/pb.PeerInfo
			*github.com/libp2p/go-libp2p-pubsub/pb.RPC
			*github.com/libp2p/go-libp2p-pubsub/pb.RPC_SubOpts
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_AddPeer
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlGraftMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIDontWantMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIHaveMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIWantMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlPruneMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DeliverMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DropRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DuplicateMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Graft
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Join
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Leave
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_MessageMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Prune
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_PublishMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RecvRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RejectMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RemovePeer
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RPCMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_SendRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_SubMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEventBatch
			 github.com/mikioh/tcpinfo.CCAlgorithm
			*github.com/mikioh/tcpinfo.CCInfo
			*github.com/mikioh/tcpinfo.Info
			 github.com/mikioh/tcpopt.Cork
			 github.com/mikioh/tcpopt.ECN
			 github.com/mikioh/tcpopt.Error
			 github.com/mikioh/tcpopt.KeepAlive
			 github.com/mikioh/tcpopt.KeepAliveIdleInterval
			 github.com/mikioh/tcpopt.KeepAliveProbeCount
			 github.com/mikioh/tcpopt.KeepAliveProbeInterval
			 github.com/mikioh/tcpopt.MSS
			 github.com/mikioh/tcpopt.NoDelay
			 github.com/mikioh/tcpopt.NotSentLowWMK
			 github.com/mikioh/tcpopt.Option (interface)
			 github.com/mikioh/tcpopt.ReceiveBuffer
			 github.com/mikioh/tcpopt.SendBuffer
			*github.com/pion/dtls/v2/pkg/protocol.ApplicationData
			*github.com/pion/dtls/v2/pkg/protocol.ChangeCipherSpec
			 github.com/pion/dtls/v2/pkg/protocol.Content (interface)
			*github.com/pion/dtls/v2/pkg/protocol/alert.Alert
			*github.com/pion/dtls/v2/pkg/protocol/extension.ALPN
			 github.com/pion/dtls/v2/pkg/protocol/extension.Extension (interface)
			*github.com/pion/dtls/v2/pkg/protocol/extension.RenegotiationInfo
			*github.com/pion/dtls/v2/pkg/protocol/extension.ServerName
			*github.com/pion/dtls/v2/pkg/protocol/extension.SupportedEllipticCurves
			*github.com/pion/dtls/v2/pkg/protocol/extension.SupportedPointFormats
			*github.com/pion/dtls/v2/pkg/protocol/extension.SupportedSignatureAlgorithms
			*github.com/pion/dtls/v2/pkg/protocol/extension.UseExtendedMasterSecret
			*github.com/pion/dtls/v2/pkg/protocol/extension.UseSRTP
			*github.com/pion/dtls/v2/pkg/protocol/handshake.Handshake
			*github.com/pion/dtls/v2/pkg/protocol/handshake.Header
			 github.com/pion/dtls/v2/pkg/protocol/handshake.Message (interface)
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageCertificate
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageCertificateRequest
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageCertificateVerify
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageClientHello
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageClientKeyExchange
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageFinished
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageHelloVerifyRequest
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageServerHello
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageServerHelloDone
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageServerKeyExchange
			*github.com/pion/dtls/v2/pkg/protocol/recordlayer.Header
			*github.com/pion/dtls/v2/pkg/protocol/recordlayer.RecordLayer
			*github.com/pion/dtls/v3/pkg/protocol.ApplicationData
			*github.com/pion/dtls/v3/pkg/protocol.ChangeCipherSpec
			 github.com/pion/dtls/v3/pkg/protocol.Content (interface)
			*github.com/pion/dtls/v3/pkg/protocol/alert.Alert
			*github.com/pion/dtls/v3/pkg/protocol/extension.ALPN
			*github.com/pion/dtls/v3/pkg/protocol/extension.ConnectionID
			 github.com/pion/dtls/v3/pkg/protocol/extension.Extension (interface)
			*github.com/pion/dtls/v3/pkg/protocol/extension.RenegotiationInfo
			*github.com/pion/dtls/v3/pkg/protocol/extension.ServerName
			*github.com/pion/dtls/v3/pkg/protocol/extension.SupportedEllipticCurves
			*github.com/pion/dtls/v3/pkg/protocol/extension.SupportedPointFormats
			*github.com/pion/dtls/v3/pkg/protocol/extension.SupportedSignatureAlgorithms
			*github.com/pion/dtls/v3/pkg/protocol/extension.UseExtendedMasterSecret
			*github.com/pion/dtls/v3/pkg/protocol/extension.UseSRTP
			*github.com/pion/dtls/v3/pkg/protocol/handshake.Handshake
			*github.com/pion/dtls/v3/pkg/protocol/handshake.Header
			 github.com/pion/dtls/v3/pkg/protocol/handshake.Message (interface)
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageCertificate
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageCertificateRequest
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageCertificateVerify
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageClientHello
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageClientKeyExchange
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageFinished
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageHelloVerifyRequest
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageServerHello
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageServerHelloDone
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageServerKeyExchange
			*github.com/pion/dtls/v3/pkg/protocol/recordlayer.Header
			*github.com/pion/dtls/v3/pkg/protocol/recordlayer.InnerPlaintext
			*github.com/pion/dtls/v3/pkg/protocol/recordlayer.RecordLayer
			 github.com/pion/rtcp.ApplicationDefined
			 github.com/pion/rtcp.CCFeedbackReport
			 github.com/pion/rtcp.CompoundPacket
			 github.com/pion/rtcp.ExtendedReport
			 github.com/pion/rtcp.FullIntraRequest
			 github.com/pion/rtcp.Goodbye
			 github.com/pion/rtcp.Header
			 github.com/pion/rtcp.Packet (interface)
			 github.com/pion/rtcp.PacketStatusChunk (interface)
			 github.com/pion/rtcp.PictureLossIndication
			 github.com/pion/rtcp.RapidResynchronizationRequest
			 github.com/pion/rtcp.RawPacket
			 github.com/pion/rtcp.ReceiverEstimatedMaximumBitrate
			 github.com/pion/rtcp.ReceiverReport
			 github.com/pion/rtcp.ReceptionReport
			 github.com/pion/rtcp.RecvDelta
			 github.com/pion/rtcp.RunLengthChunk
			 github.com/pion/rtcp.SenderReport
			 github.com/pion/rtcp.SliceLossIndication
			 github.com/pion/rtcp.SourceDescription
			 github.com/pion/rtcp.SourceDescriptionChunk
			 github.com/pion/rtcp.SourceDescriptionItem
			 github.com/pion/rtcp.StatusVectorChunk
			 github.com/pion/rtcp.TransportLayerCC
			 github.com/pion/rtcp.TransportLayerNack
			 github.com/pion/rtp.AbsCaptureTimeExtension
			 github.com/pion/rtp.AbsSendTimeExtension
			 github.com/pion/rtp.AudioLevelExtension
			 github.com/pion/rtp.Header
			 github.com/pion/rtp.HeaderExtension (interface)
			 github.com/pion/rtp.OneByteHeaderExtension
			 github.com/pion/rtp.Packet
			 github.com/pion/rtp.PlayoutDelayExtension
			 github.com/pion/rtp.RawExtension
			 github.com/pion/rtp.TransportCCExtension
			 github.com/pion/rtp.TwoByteHeaderExtension
			 github.com/pion/rtp.VLA
			*github.com/pion/sdp/v3.SessionDescription
			*golang.org/x/net/ipv4.Header
		Implements (at least one exported)
			 Marshaler : github.com/golang/protobuf/proto.Marshaler

	 type Merger (interface)
		Merger is the interface representing objects that can merge messages of the same type.

		Methods (only one)
			( Merger) Merge(src Message)
				Merge merges src into this message.
				Required and optional fields that are set in src will be set to that value in dst.
				Elements of repeated fields will be appended.
				
				Merge may panic if called with a different argument type than the receiver.


	 type Message (interface)
		Message is implemented by generated protocol buffer messages.

		Methods (total 3)
			( Message) ProtoMessage()
			( Message) Reset()
			( Message) String() string
		Implemented By (at least 209)
			 github.com/golang/protobuf/ptypes.DynamicAny
			*github.com/hibiken/asynq/internal/proto.SchedulerEnqueueEvent
			*github.com/hibiken/asynq/internal/proto.SchedulerEntry
			*github.com/hibiken/asynq/internal/proto.ServerInfo
			*github.com/hibiken/asynq/internal/proto.TaskMessage
			*github.com/hibiken/asynq/internal/proto.WorkerInfo
			*github.com/libp2p/go-libp2p/core/crypto/pb.PrivateKey
			*github.com/libp2p/go-libp2p/core/crypto/pb.PublicKey
			*github.com/libp2p/go-libp2p/core/peer/pb.PeerRecord
			*github.com/libp2p/go-libp2p/core/peer/pb.PeerRecord_AddressInfo
			*github.com/libp2p/go-libp2p/core/record/pb.Envelope
			*github.com/libp2p/go-libp2p/core/sec/insecure/pb.Exchange
			*github.com/libp2p/go-libp2p/p2p/host/autonat/pb.Message
			*github.com/libp2p/go-libp2p/p2p/host/autonat/pb.Message_Dial
			*github.com/libp2p/go-libp2p/p2p/host/autonat/pb.Message_DialResponse
			*github.com/libp2p/go-libp2p/p2p/host/autonat/pb.Message_PeerInfo
			*github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb.DialBack
			*github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb.DialBackResponse
			*github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb.DialDataRequest
			*github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb.DialDataResponse
			*github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb.DialRequest
			*github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb.DialResponse
			*github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb.Message
			*github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/pb.HopMessage
			*github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/pb.Limit
			*github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/pb.Peer
			*github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/pb.Reservation
			*github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/pb.ReservationVoucher
			*github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/pb.StopMessage
			*github.com/libp2p/go-libp2p/p2p/protocol/holepunch/pb.HolePunch
			*github.com/libp2p/go-libp2p/p2p/protocol/identify/pb.Identify
			*github.com/libp2p/go-libp2p/p2p/security/noise/pb.NoiseExtensions
			*github.com/libp2p/go-libp2p/p2p/security/noise/pb.NoiseHandshakePayload
			*github.com/libp2p/go-libp2p/p2p/transport/webrtc/pb.Message
			 github.com/libp2p/go-libp2p-pubsub.Message
			*github.com/libp2p/go-libp2p-pubsub.RPC
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlGraft
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIDontWant
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIHave
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIWant
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlPrune
			*github.com/libp2p/go-libp2p-pubsub/pb.Message
			*github.com/libp2p/go-libp2p-pubsub/pb.PeerInfo
			*github.com/libp2p/go-libp2p-pubsub/pb.RPC
			*github.com/libp2p/go-libp2p-pubsub/pb.RPC_SubOpts
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_AddPeer
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlGraftMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIDontWantMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIHaveMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIWantMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlPruneMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DeliverMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DropRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DuplicateMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Graft
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Join
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Leave
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_MessageMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Prune
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_PublishMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RecvRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RejectMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RemovePeer
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RPCMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_SendRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_SubMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEventBatch
			*github.com/pancsta/asyncmachine-go/examples/benchmark_grpc/proto.CallOpRequest
			*github.com/pancsta/asyncmachine-go/examples/benchmark_grpc/proto.CallOpResponse
			*github.com/pancsta/asyncmachine-go/examples/benchmark_grpc/proto.Empty
			*github.com/pancsta/asyncmachine-go/examples/benchmark_grpc/proto.GetValueResponse
			*github.com/pancsta/asyncmachine-go/examples/benchmark_grpc/worker_proto.CallOpRequest
			*github.com/pancsta/asyncmachine-go/examples/benchmark_grpc/worker_proto.CallOpResponse
			*github.com/pancsta/asyncmachine-go/examples/benchmark_grpc/worker_proto.Empty
			*github.com/pancsta/asyncmachine-go/examples/benchmark_grpc/worker_proto.GetValueResponse
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/schema/v1alpha1.Column
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/schema/v1alpha1.Schema
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/schema/v1alpha1.SortingColumn
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/schema/v1alpha1.StorageLayout
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/schema/v1alpha2.Group
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/schema/v1alpha2.Leaf
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/schema/v1alpha2.Node
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/schema/v1alpha2.Schema
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/schema/v1alpha2.SortingColumn
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/schema/v1alpha2.StorageLayout
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/snapshot/v1alpha1.FooterData
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/snapshot/v1alpha1.Granule
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/snapshot/v1alpha1.Part
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/snapshot/v1alpha1.Table
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/snapshot/v1alpha1.Table_TableBlock
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/table/v1alpha1.TableConfig
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/wal/v1alpha1.Entry
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/wal/v1alpha1.Entry_NewTableBlock
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/wal/v1alpha1.Entry_Snapshot
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/wal/v1alpha1.Entry_TableBlockPersisted
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/wal/v1alpha1.Entry_Write
			*github.com/polarsignals/frostdb/gen/proto/go/frostdb/wal/v1alpha1.Record
			*github.com/prometheus/client_model/go.Bucket
			*github.com/prometheus/client_model/go.BucketSpan
			*github.com/prometheus/client_model/go.Counter
			*github.com/prometheus/client_model/go.Exemplar
			*github.com/prometheus/client_model/go.Gauge
			*github.com/prometheus/client_model/go.Histogram
			*github.com/prometheus/client_model/go.LabelPair
			*github.com/prometheus/client_model/go.Metric
			*github.com/prometheus/client_model/go.MetricFamily
			*github.com/prometheus/client_model/go.Quantile
			*github.com/prometheus/client_model/go.Summary
			*github.com/prometheus/client_model/go.Untyped
			*go.opentelemetry.io/proto/otlp/collector/trace/v1.ExportTracePartialSuccess
			*go.opentelemetry.io/proto/otlp/collector/trace/v1.ExportTraceServiceRequest
			*go.opentelemetry.io/proto/otlp/collector/trace/v1.ExportTraceServiceResponse
			*go.opentelemetry.io/proto/otlp/common/v1.AnyValue
			*go.opentelemetry.io/proto/otlp/common/v1.ArrayValue
			*go.opentelemetry.io/proto/otlp/common/v1.EntityRef
			*go.opentelemetry.io/proto/otlp/common/v1.InstrumentationScope
			*go.opentelemetry.io/proto/otlp/common/v1.KeyValue
			*go.opentelemetry.io/proto/otlp/common/v1.KeyValueList
			*go.opentelemetry.io/proto/otlp/resource/v1.Resource
			*go.opentelemetry.io/proto/otlp/trace/v1.ResourceSpans
			*go.opentelemetry.io/proto/otlp/trace/v1.ScopeSpans
			*go.opentelemetry.io/proto/otlp/trace/v1.Span
			*go.opentelemetry.io/proto/otlp/trace/v1.Span_Event
			*go.opentelemetry.io/proto/otlp/trace/v1.Span_Link
			*go.opentelemetry.io/proto/otlp/trace/v1.Status
			*go.opentelemetry.io/proto/otlp/trace/v1.TracesData
			*google.golang.org/genproto/googleapis/api/httpbody.HttpBody
			*google.golang.org/genproto/googleapis/rpc/errdetails.BadRequest
			*google.golang.org/genproto/googleapis/rpc/errdetails.BadRequest_FieldViolation
			*google.golang.org/genproto/googleapis/rpc/errdetails.DebugInfo
			*google.golang.org/genproto/googleapis/rpc/errdetails.ErrorInfo
			*google.golang.org/genproto/googleapis/rpc/errdetails.Help
			*google.golang.org/genproto/googleapis/rpc/errdetails.Help_Link
			*google.golang.org/genproto/googleapis/rpc/errdetails.LocalizedMessage
			*google.golang.org/genproto/googleapis/rpc/errdetails.PreconditionFailure
			*google.golang.org/genproto/googleapis/rpc/errdetails.PreconditionFailure_Violation
			*google.golang.org/genproto/googleapis/rpc/errdetails.QuotaFailure
			*google.golang.org/genproto/googleapis/rpc/errdetails.QuotaFailure_Violation
			*google.golang.org/genproto/googleapis/rpc/errdetails.RequestInfo
			*google.golang.org/genproto/googleapis/rpc/errdetails.ResourceInfo
			*google.golang.org/genproto/googleapis/rpc/errdetails.RetryInfo
			*google.golang.org/genproto/googleapis/rpc/status.Status
			*google.golang.org/grpc/binarylog/grpc_binarylog_v1.Address
			*google.golang.org/grpc/binarylog/grpc_binarylog_v1.ClientHeader
			*google.golang.org/grpc/binarylog/grpc_binarylog_v1.GrpcLogEntry
			*google.golang.org/grpc/binarylog/grpc_binarylog_v1.Message
			*google.golang.org/grpc/binarylog/grpc_binarylog_v1.Metadata
			*google.golang.org/grpc/binarylog/grpc_binarylog_v1.MetadataEntry
			*google.golang.org/grpc/binarylog/grpc_binarylog_v1.ServerHeader
			*google.golang.org/grpc/binarylog/grpc_binarylog_v1.Trailer
			*google.golang.org/grpc/health/grpc_health_v1.HealthCheckRequest
			*google.golang.org/grpc/health/grpc_health_v1.HealthCheckResponse
			*google.golang.org/grpc/health/grpc_health_v1.HealthListRequest
			*google.golang.org/grpc/health/grpc_health_v1.HealthListResponse
			 google.golang.org/protobuf/runtime/protoiface.MessageV1 (interface)
			*google.golang.org/protobuf/types/descriptorpb.DescriptorProto
			*google.golang.org/protobuf/types/descriptorpb.DescriptorProto_ExtensionRange
			*google.golang.org/protobuf/types/descriptorpb.DescriptorProto_ReservedRange
			*google.golang.org/protobuf/types/descriptorpb.EnumDescriptorProto
			*google.golang.org/protobuf/types/descriptorpb.EnumDescriptorProto_EnumReservedRange
			*google.golang.org/protobuf/types/descriptorpb.EnumOptions
			*google.golang.org/protobuf/types/descriptorpb.EnumValueDescriptorProto
			*google.golang.org/protobuf/types/descriptorpb.EnumValueOptions
			*google.golang.org/protobuf/types/descriptorpb.ExtensionRangeOptions
			*google.golang.org/protobuf/types/descriptorpb.ExtensionRangeOptions_Declaration
			*google.golang.org/protobuf/types/descriptorpb.FeatureSet
			*google.golang.org/protobuf/types/descriptorpb.FeatureSet_VisibilityFeature
			*google.golang.org/protobuf/types/descriptorpb.FeatureSetDefaults
			*google.golang.org/protobuf/types/descriptorpb.FeatureSetDefaults_FeatureSetEditionDefault
			*google.golang.org/protobuf/types/descriptorpb.FieldDescriptorProto
			*google.golang.org/protobuf/types/descriptorpb.FieldOptions
			*google.golang.org/protobuf/types/descriptorpb.FieldOptions_EditionDefault
			*google.golang.org/protobuf/types/descriptorpb.FieldOptions_FeatureSupport
			*google.golang.org/protobuf/types/descriptorpb.FileDescriptorProto
			*google.golang.org/protobuf/types/descriptorpb.FileDescriptorSet
			*google.golang.org/protobuf/types/descriptorpb.FileOptions
			*google.golang.org/protobuf/types/descriptorpb.GeneratedCodeInfo
			*google.golang.org/protobuf/types/descriptorpb.GeneratedCodeInfo_Annotation
			*google.golang.org/protobuf/types/descriptorpb.MessageOptions
			*google.golang.org/protobuf/types/descriptorpb.MethodDescriptorProto
			*google.golang.org/protobuf/types/descriptorpb.MethodOptions
			*google.golang.org/protobuf/types/descriptorpb.OneofDescriptorProto
			*google.golang.org/protobuf/types/descriptorpb.OneofOptions
			*google.golang.org/protobuf/types/descriptorpb.ServiceDescriptorProto
			*google.golang.org/protobuf/types/descriptorpb.ServiceOptions
			*google.golang.org/protobuf/types/descriptorpb.SourceCodeInfo
			*google.golang.org/protobuf/types/descriptorpb.SourceCodeInfo_Location
			*google.golang.org/protobuf/types/descriptorpb.UninterpretedOption
			*google.golang.org/protobuf/types/descriptorpb.UninterpretedOption_NamePart
			*google.golang.org/protobuf/types/gofeaturespb.GoFeatures
			*google.golang.org/protobuf/types/known/anypb.Any
			*google.golang.org/protobuf/types/known/durationpb.Duration
			*google.golang.org/protobuf/types/known/fieldmaskpb.FieldMask
			*google.golang.org/protobuf/types/known/structpb.ListValue
			*google.golang.org/protobuf/types/known/structpb.Struct
			*google.golang.org/protobuf/types/known/structpb.Value
			*google.golang.org/protobuf/types/known/timestamppb.Timestamp
			*google.golang.org/protobuf/types/known/wrapperspb.BoolValue
			*google.golang.org/protobuf/types/known/wrapperspb.BytesValue
			*google.golang.org/protobuf/types/known/wrapperspb.DoubleValue
			*google.golang.org/protobuf/types/known/wrapperspb.FloatValue
			*google.golang.org/protobuf/types/known/wrapperspb.Int32Value
			*google.golang.org/protobuf/types/known/wrapperspb.Int64Value
			*google.golang.org/protobuf/types/known/wrapperspb.StringValue
			*google.golang.org/protobuf/types/known/wrapperspb.UInt32Value
			*google.golang.org/protobuf/types/known/wrapperspb.UInt64Value
		Implements (at least 3)
			 Message : expvar.Var
			 Message : fmt.Stringer
			 Message : google.golang.org/protobuf/runtime/protoiface.MessageV1
		As Outputs Of (at least one exported)
			func Clone(src Message) Message
		As Inputs Of (at least 82)
			func AppendExtension(e Message, tag int32, buf []byte)
			func ClearAllExtensions(pb Message)
			func ClearExtension(pb Message, extension *ExtensionDesc)
			func Clone(src Message) Message
			func CompactText(w io.Writer, pb Message) error
			func CompactTextString(pb Message) string
			func DiscardUnknown(m Message)
			func Equal(a, b Message) bool
			func ExtensionDescs(pb Message) ([]*ExtensionDesc, error)
			func GetBoolExtension(pb Message, extension *ExtensionDesc, ifnotset bool) bool
			func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error)
			func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error)
			func GetUnsafeExtension(pb Message, fieldNum int32) (interface{}, error)
			func GetUnsafeExtensionsMap(extendable Message) map[int32]Extension
			func HasExtension(pb Message, extension *ExtensionDesc) bool
			func Marshal(pb Message) ([]byte, error)
			func MarshalText(w io.Writer, pb Message) error
			func MarshalTextString(pb Message) string
			func Merge(dst, src Message)
			func MessageName(x Message) string
			func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc
			func RegisterMessageSetType(Message, int32, string)
			func RegisterType(x Message, name string)
			func SetDefaults(pb Message)
			func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error
			func SetRawExtension(base Message, id int32, b []byte)
			func SetUnsafeExtension(pb Message, fieldNum int32, value interface{}) error
			func Size(pb Message) int
			func Unmarshal(buf []byte, pb Message) error
			func UnmarshalMerge(buf []byte, pb Message) error
			func UnmarshalText(s string, pb Message) error
			func (*Buffer).DecodeGroup(pb Message) error
			func (*Buffer).DecodeMessage(pb Message) error
			func (*Buffer).EncodeMessage(pb Message) error
			func (*Buffer).Marshal(pb Message) error
			func (*Buffer).Unmarshal(pb Message) error
			func (*InternalMessageInfo).DiscardUnknown(m Message)
			func (*InternalMessageInfo).Marshal(b []byte, msg Message, deterministic bool) ([]byte, error)
			func (*InternalMessageInfo).Merge(dst, src Message)
			func (*InternalMessageInfo).Size(msg Message) int
			func (*InternalMessageInfo).Unmarshal(msg Message, b []byte) error
			func Merger.Merge(src Message)
			func (*TextMarshaler).Marshal(w io.Writer, pb Message) error
			func (*TextMarshaler).Text(pb Message) string
			func github.com/libp2p/go-libp2p-pubsub/pb.(*ControlGraft).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*ControlIDontWant).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*ControlIHave).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*ControlIWant).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*ControlMessage).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*ControlPrune).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*Message).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*PeerInfo).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*RPC).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*RPC_SubOpts).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_AddPeer).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_ControlGraftMeta).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_ControlIDontWantMeta).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_ControlIHaveMeta).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_ControlIWantMeta).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_ControlMeta).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_ControlPruneMeta).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_DeliverMessage).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_DropRPC).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_DuplicateMessage).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_Graft).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_Join).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_Leave).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_MessageMeta).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_Prune).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_PublishMessage).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_RecvRPC).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_RejectMessage).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_RemovePeer).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_RPCMeta).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_SendRPC).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEvent_SubMeta).XXX_Merge(src Message)
			func github.com/libp2p/go-libp2p-pubsub/pb.(*TraceEventBatch).XXX_Merge(src Message)
			func github.com/libp2p/go-msgio/protoio.ReadCloser.ReadMsg(msg Message) error
			func github.com/libp2p/go-msgio/protoio.Reader.ReadMsg(msg Message) error
			func github.com/libp2p/go-msgio/protoio.WriteCloser.WriteMsg(Message) error
			func github.com/libp2p/go-msgio/protoio.Writer.WriteMsg(Message) error

	 type OneofProperties (struct)
		OneofProperties represents information about a specific field in a oneof.

		Fields (total 3)
			Field int
				// struct field number of the containing oneof in the message

			Prop *Properties
			Type reflect.Type
				// pointer to generated struct type for this oneof field


	 type ParseError (struct)

		Fields (total 3)
			Line int
				// 1-based line number

			Message string
			Offset int
				// 0-based byte offset from start of input

		Methods (only one)
			(*ParseError) Error() string
		Implements (at least one exported)
			*ParseError : error

	 type Properties (struct)
		Properties represents the protocol-specific behavior of a single struct field.

		Fields (total 20)
			CastType string
			CustomType string
			Default string
				// default value

			Enum string
				// set for enum types only

			HasDefault bool
				// whether an explicit default was provided

			JSONName string
				// name to use for JSON; determined by protoc

			MapKeyProp *Properties
				// set for map types only

			MapValProp *Properties
				// set for map types only

			Name string
				// name of the field, for error messages

			Optional bool
			OrigName string
				// original name before protocol compiler (always set)

			Packed bool
				// relevant for repeated primitives only

			Repeated bool
			Required bool
			StdDuration bool
			StdTime bool
			Tag int
			Wire string
			WireType int
			WktPointer bool
		Methods (total 3)
			(*Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField)
				Init populates the properties from a protocol buffer struct tag.

			(*Properties) Parse(s string)
				Parse populates p by parsing a string in the protobuf struct field tag style.

			(*Properties) String() string
				String formats the properties in the protobuf struct field tag style.

		Implements (at least 2)
			*Properties : expvar.Var
			*Properties : fmt.Stringer

	 type ProtoSizer (interface)

		Methods (only one)
			( ProtoSizer) ProtoSize() int

	 type RequiredNotSetError (struct)
		RequiredNotSetError is an error type returned by either Marshal or Unmarshal.
		Marshal reports this when a required field is not initialized.
		Unmarshal reports this when a required field is missing from the wire data.

		Methods (total 2)
			(*RequiredNotSetError) Error() string
			(*RequiredNotSetError) RequiredNotSet() bool
		Implements (at least one exported)
			*RequiredNotSetError : error
		As Outputs Of (at least one exported)
			func NewRequiredNotSetError(field string) *RequiredNotSetError

	 type Sizer (interface)

		Methods (only one)
			( Sizer) Size() int
		Implemented By (at least 92)
			*github.com/apache/arrow-go/v18/internal/hashing.BinaryMemoTable
			 github.com/apache/arrow-go/v18/internal/hashing.MemoTable[T] (interface)
			 github.com/apache/arrow-go/v18/internal/hashing.NumericMemoTable (interface)
			*github.com/apache/arrow-go/v18/internal/hashing.Table[...]
			 github.com/apache/arrow-go/v18/internal/hashing.TypedMemoTable[...] (interface)
			*github.com/cespare/xxhash/v2.Digest
			*github.com/go-echarts/go-echarts/v2/types.OrderedSet
			 github.com/gobwas/httphead.Option
			*github.com/gobwas/httphead.Parameters
			*github.com/gobwas/ws/wsutil.Writer
			*github.com/hamba/avro/v2.FixedSchema
			 github.com/json-iterator/go.Any (interface)
			*github.com/klauspost/compress/zstd/internal/xxhash.Digest
			*github.com/libp2p/go-buffer-pool.Writer
			 github.com/libp2p/go-libp2p/core/peer.ID
			 github.com/libp2p/go-libp2p-pubsub.Message
			*github.com/libp2p/go-libp2p-pubsub.RPC
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlGraft
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIDontWant
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIHave
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIWant
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlPrune
			*github.com/libp2p/go-libp2p-pubsub/pb.Message
			*github.com/libp2p/go-libp2p-pubsub/pb.PeerInfo
			*github.com/libp2p/go-libp2p-pubsub/pb.RPC
			*github.com/libp2p/go-libp2p-pubsub/pb.RPC_SubOpts
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_AddPeer
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlGraftMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIDontWantMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIHaveMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIWantMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlPruneMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DeliverMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DropRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DuplicateMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Graft
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Join
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Leave
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_MessageMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Prune
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_PublishMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RecvRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RejectMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RemovePeer
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RPCMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_SendRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_SubMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEventBatch
			*github.com/mailru/easyjson/buffer.Buffer
			*github.com/mailru/easyjson/jwriter.Writer
			*github.com/nats-io/nats.go.Msg
			*github.com/pierrec/lz4/v4.Reader
			*github.com/pierrec/lz4/v4/internal/xxh32.XXHZero
			*github.com/pion/dtls/v3/pkg/protocol/recordlayer.Header
			*github.com/pion/rtp/codecs/av1/obu.Header
			*github.com/pion/transport/v2/packetio.Buffer
			*github.com/pion/transport/v3/packetio.Buffer
			*github.com/pion/turn/v4/internal/client.TransactionMap
			 github.com/PuerkitoBio/goquery.Document
			*github.com/PuerkitoBio/goquery.Selection
			 github.com/spaolacci/murmur3.Hash128 (interface)
			*github.com/zeebo/xxh3.Hasher
			*bufio.Reader
			*bufio.Writer
			 crypto.Hash
			*crypto/internal/fips140/bigmod.Modulus
			*crypto/internal/fips140/hmac.HMAC
			*crypto/internal/fips140/rsa.PublicKey
			*crypto/internal/fips140/sha256.Digest
			*crypto/internal/fips140/sha3.Digest
			*crypto/internal/fips140/sha3.SHAKE
			*crypto/internal/fips140/sha512.Digest
			*crypto/rsa.PrivateKey
			*crypto/rsa.PublicKey
			*crypto/sha3.SHA3
			*go/token.File
			*golang.org/x/crypto/internal/poly1305.MAC
			 golang.org/x/crypto/sha3.ShakeHash (interface)
			*golang.org/x/sys/unix.FileHandle
			 golang.org/x/text/unicode/norm.Properties
			 hash.Cloner (interface)
			 hash.Hash (interface)
			 hash.Hash32 (interface)
			 hash.Hash64 (interface)
			*hash/maphash.Hash
			*lukechampine.com/blake3.Hasher
			 net/http/internal.FlushAfterChunkWriter
			*vendor/golang.org/x/crypto/internal/poly1305.MAC
			 vendor/golang.org/x/text/unicode/norm.Properties

	 type Stats (struct)
		Deprecated: do not use.

		Fields (total 7)
			Chit uint64
			Cmiss uint64
			Decode uint64
			Dmalloc uint64
			Emalloc uint64
			Encode uint64
			Size uint64
		As Outputs Of (at least one exported)
			func GetStats() Stats

	 type StructProperties (struct)
		StructProperties represents properties for all the fields of a struct.
		decoderTags and decoderOrigNames should only be used by the decoder.

		Fields (total 2)
			OneofTypes map[string]*OneofProperties
				OneofTypes contains information about the oneof fields in this message.
				It is keyed by the original name of a field.

			Prop []*Properties
				// properties for each field

		Methods (total 3)
			(*StructProperties) Len() int
			(*StructProperties) Less(i, j int) bool
			(*StructProperties) Swap(i, j int)
		Implements (at least one exported)
			*StructProperties : sort.Interface
		As Outputs Of (at least one exported)
			func GetProperties(t reflect.Type) *StructProperties

	 type TextMarshaler (struct)
		TextMarshaler is a configurable text format marshaler.

		Fields (total 2)
			Compact bool
				// use compact text format (one line).

			ExpandAny bool
				// expand google.protobuf.Any messages of known types

		Methods (total 2)
			(*TextMarshaler) Marshal(w io.Writer, pb Message) error
				Marshal writes a given protocol buffer in text format.
				The only errors returned are from w.

			(*TextMarshaler) Text(pb Message) string
				Text is the same as Marshal, but returns the string directly.


	 type Unmarshaler (interface)
		Unmarshaler is the interface representing objects that can
		unmarshal themselves.  The argument points to data that may be
		overwritten, so implementations should not keep references to the
		buffer.
		Unmarshal implementations should not clear the receiver.
		Any unmarshaled data should be merged into the receiver.
		Callers of Unmarshal that do not want to retain existing data
		should Reset the receiver before calling Unmarshal.

		Methods (only one)
			( Unmarshaler) Unmarshal([]byte) error
		Implemented By (at least 129)
			 github.com/golang/protobuf/proto.Unmarshaler (interface)
			*github.com/libp2p/go-libp2p/core/peer.ID
			 github.com/libp2p/go-libp2p-pubsub.Message
			*github.com/libp2p/go-libp2p-pubsub.RPC
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlGraft
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIDontWant
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIHave
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlIWant
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.ControlPrune
			*github.com/libp2p/go-libp2p-pubsub/pb.Message
			*github.com/libp2p/go-libp2p-pubsub/pb.PeerInfo
			*github.com/libp2p/go-libp2p-pubsub/pb.RPC
			*github.com/libp2p/go-libp2p-pubsub/pb.RPC_SubOpts
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_AddPeer
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlGraftMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIDontWantMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIHaveMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlIWantMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_ControlPruneMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DeliverMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DropRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_DuplicateMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Graft
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Join
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Leave
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_MessageMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_Prune
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_PublishMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RecvRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RejectMessage
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RemovePeer
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_RPCMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_SendRPC
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEvent_SubMeta
			*github.com/libp2p/go-libp2p-pubsub/pb.TraceEventBatch
			*github.com/pion/dtls/v2/pkg/protocol.ApplicationData
			*github.com/pion/dtls/v2/pkg/protocol.ChangeCipherSpec
			 github.com/pion/dtls/v2/pkg/protocol.Content (interface)
			*github.com/pion/dtls/v2/pkg/protocol/alert.Alert
			*github.com/pion/dtls/v2/pkg/protocol/extension.ALPN
			 github.com/pion/dtls/v2/pkg/protocol/extension.Extension (interface)
			*github.com/pion/dtls/v2/pkg/protocol/extension.RenegotiationInfo
			*github.com/pion/dtls/v2/pkg/protocol/extension.ServerName
			*github.com/pion/dtls/v2/pkg/protocol/extension.SupportedEllipticCurves
			*github.com/pion/dtls/v2/pkg/protocol/extension.SupportedPointFormats
			*github.com/pion/dtls/v2/pkg/protocol/extension.SupportedSignatureAlgorithms
			*github.com/pion/dtls/v2/pkg/protocol/extension.UseExtendedMasterSecret
			*github.com/pion/dtls/v2/pkg/protocol/extension.UseSRTP
			*github.com/pion/dtls/v2/pkg/protocol/handshake.Handshake
			*github.com/pion/dtls/v2/pkg/protocol/handshake.Header
			 github.com/pion/dtls/v2/pkg/protocol/handshake.Message (interface)
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageCertificate
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageCertificateRequest
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageCertificateVerify
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageClientHello
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageClientKeyExchange
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageFinished
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageHelloVerifyRequest
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageServerHello
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageServerHelloDone
			*github.com/pion/dtls/v2/pkg/protocol/handshake.MessageServerKeyExchange
			*github.com/pion/dtls/v2/pkg/protocol/recordlayer.Header
			*github.com/pion/dtls/v2/pkg/protocol/recordlayer.RecordLayer
			*github.com/pion/dtls/v3/pkg/protocol.ApplicationData
			*github.com/pion/dtls/v3/pkg/protocol.ChangeCipherSpec
			 github.com/pion/dtls/v3/pkg/protocol.Content (interface)
			*github.com/pion/dtls/v3/pkg/protocol/alert.Alert
			*github.com/pion/dtls/v3/pkg/protocol/extension.ALPN
			*github.com/pion/dtls/v3/pkg/protocol/extension.ConnectionID
			 github.com/pion/dtls/v3/pkg/protocol/extension.Extension (interface)
			*github.com/pion/dtls/v3/pkg/protocol/extension.RenegotiationInfo
			*github.com/pion/dtls/v3/pkg/protocol/extension.ServerName
			*github.com/pion/dtls/v3/pkg/protocol/extension.SupportedEllipticCurves
			*github.com/pion/dtls/v3/pkg/protocol/extension.SupportedPointFormats
			*github.com/pion/dtls/v3/pkg/protocol/extension.SupportedSignatureAlgorithms
			*github.com/pion/dtls/v3/pkg/protocol/extension.UseExtendedMasterSecret
			*github.com/pion/dtls/v3/pkg/protocol/extension.UseSRTP
			*github.com/pion/dtls/v3/pkg/protocol/handshake.Handshake
			*github.com/pion/dtls/v3/pkg/protocol/handshake.Header
			 github.com/pion/dtls/v3/pkg/protocol/handshake.Message (interface)
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageCertificate
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageCertificateRequest
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageCertificateVerify
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageClientHello
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageClientKeyExchange
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageFinished
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageHelloVerifyRequest
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageServerHello
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageServerHelloDone
			*github.com/pion/dtls/v3/pkg/protocol/handshake.MessageServerKeyExchange
			*github.com/pion/dtls/v3/pkg/protocol/recordlayer.Header
			*github.com/pion/dtls/v3/pkg/protocol/recordlayer.InnerPlaintext
			*github.com/pion/dtls/v3/pkg/protocol/recordlayer.RecordLayer
			*github.com/pion/rtcp.ApplicationDefined
			*github.com/pion/rtcp.CCFeedbackReport
			*github.com/pion/rtcp.CompoundPacket
			*github.com/pion/rtcp.ExtendedReport
			*github.com/pion/rtcp.FullIntraRequest
			*github.com/pion/rtcp.Goodbye
			*github.com/pion/rtcp.Header
			 github.com/pion/rtcp.Packet (interface)
			 github.com/pion/rtcp.PacketStatusChunk (interface)
			*github.com/pion/rtcp.PictureLossIndication
			*github.com/pion/rtcp.RapidResynchronizationRequest
			*github.com/pion/rtcp.RawPacket
			*github.com/pion/rtcp.ReceiverEstimatedMaximumBitrate
			*github.com/pion/rtcp.ReceiverReport
			*github.com/pion/rtcp.ReceptionReport
			*github.com/pion/rtcp.RecvDelta
			*github.com/pion/rtcp.RunLengthChunk
			*github.com/pion/rtcp.SenderReport
			*github.com/pion/rtcp.SliceLossIndication
			*github.com/pion/rtcp.SourceDescription
			*github.com/pion/rtcp.SourceDescriptionChunk
			*github.com/pion/rtcp.SourceDescriptionItem
			*github.com/pion/rtcp.StatusVectorChunk
			*github.com/pion/rtcp.TransportLayerCC
			*github.com/pion/rtcp.TransportLayerNack
			*github.com/pion/rtp.AbsCaptureTimeExtension
			*github.com/pion/rtp.AbsSendTimeExtension
			*github.com/pion/rtp.AudioLevelExtension
			*github.com/pion/rtp.Packet
			*github.com/pion/rtp.PlayoutDelayExtension
			*github.com/pion/rtp.TransportCCExtension
			*github.com/pion/rtp/codecs/vp9.Header
			*github.com/pion/sdp/v3.SessionDescription
		Implements (at least one exported)
			 Unmarshaler : github.com/golang/protobuf/proto.Unmarshaler

	 type XXX_InternalExtensions (struct)
		XXX_InternalExtensions is an internal representation of proto extensions.
		
		Each generated message struct type embeds an anonymous XXX_InternalExtensions field,
		thus gaining the unexported 'extensions' method, which can be called only from the proto package.
		
		The methods of XXX_InternalExtensions are not concurrency safe in general,
		but calls to logically read-only methods such as has and get may be executed concurrently.

		As Outputs Of (at least one exported)
			func NewUnsafeXXX_InternalExtensions(m map[int32]Extension) XXX_InternalExtensions


Package-Level Functions (total 74)

	 func AppendExtension(e Message, tag int32, buf []byte)
	 func Bool(v bool) *bool
		Bool is a helper routine that allocates a new bool value
		to store v and returns a pointer to it.

	 func BytesToExtensionsMap(buf []byte) (map[int32]Extension, error)
	 func ClearAllExtensions(pb Message)
		ClearAllExtensions clears all extensions from pb.

	 func ClearExtension(pb Message, extension *ExtensionDesc)
		ClearExtension removes the given extension from pb.

	 func Clone(src Message) Message
		Clone returns a deep copy of a protocol buffer.

	 func CompactText(w io.Writer, pb Message) error
		CompactText writes a given protocol buffer in compact text format (one line).

	 func CompactTextString(pb Message) string
		CompactTextString is the same as CompactText, but returns the string directly.

	 func DecodeVarint(buf []byte) (x uint64, n int)
		DecodeVarint reads a varint-encoded integer from the slice.
		It returns the integer and the number of bytes consumed, or
		zero if there is not enough.
		This is the format for the
		int32, int64, uint32, uint64, bool, and enum
		protocol buffer types.

	 func DiscardUnknown(m Message)
		DiscardUnknown recursively discards all unknown fields from this message
		and all embedded messages.
		
		When unmarshaling a message with unrecognized fields, the tags and values
		of such fields are preserved in the Message. This allows a later call to
		marshal to be able to produce a message that continues to have those
		unrecognized fields. To avoid this, DiscardUnknown is used to
		explicitly clear the unknown fields after unmarshaling.
		
		For proto2 messages, the unknown fields of message extensions are only
		discarded from messages that have been accessed via GetExtension.

	 func EncodeExtensionMap(m map[int32]Extension, data []byte) (n int, err error)
	 func EncodeExtensionMapBackwards(m map[int32]Extension, data []byte) (n int, err error)
	 func EncodeInternalExtension(m extendableProto, data []byte) (n int, err error)
	 func EncodeInternalExtensionBackwards(m extendableProto, data []byte) (n int, err error)
	 func EncodeVarint(x uint64) []byte
		EncodeVarint returns the varint encoding of x.
		This is the format for the
		int32, int64, uint32, uint64, bool, and enum
		protocol buffer types.
		Not used by the package itself, but helpful to clients
		wishing to use the same encoding.

	 func EnumName(m map[int32]string, v int32) string
		EnumName is a helper function to simplify printing protocol buffer enums
		by name.  Given an enum map and a value, it returns a useful string.

	 func EnumValueMap(enumType string) map[string]int32
		EnumValueMap returns the mapping from names to integers of the
		enum type enumType, or a nil if not found.

	 func Equal(a, b Message) bool
		Equal returns true iff protocol buffers a and b are equal.
		The arguments must both be pointers to protocol buffer structs.
		
		Equality is defined in this way:
		  - Two messages are equal iff they are the same type,
		    corresponding fields are equal, unknown field sets
		    are equal, and extensions sets are equal.
		  - Two set scalar fields are equal iff their values are equal.
		    If the fields are of a floating-point type, remember that
		    NaN != x for all x, including NaN. If the message is defined
		    in a proto3 .proto file, fields are not "set"; specifically,
		    zero length proto3 "bytes" fields are equal (nil == {}).
		  - Two repeated fields are equal iff their lengths are the same,
		    and their corresponding elements are equal. Note a "bytes" field,
		    although represented by []byte, is not a repeated field and the
		    rule for the scalar fields described above applies.
		  - Two unset fields are equal.
		  - Two unknown field sets are equal if their current
		    encoded state is equal.
		  - Two extension sets are equal iff they have corresponding
		    elements that are pairwise equal.
		  - Two map fields are equal iff their lengths are the same,
		    and they contain the same set of elements. Zero-length map
		    fields are equal.
		  - Every other combination of things are not equal.
		
		The return value is undefined if a and b are not protocol buffers.

	 func ExtensionDescs(pb Message) ([]*ExtensionDesc, error)
		ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order.
		For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing
		just the Field field, which defines the extension's field number.

	 func FileDescriptor(filename string) []byte
		FileDescriptor returns the compressed FileDescriptorProto for a .proto file.

	 func Float32(v float32) *float32
		Float32 is a helper routine that allocates a new float32 value
		to store v and returns a pointer to it.

	 func Float64(v float64) *float64
		Float64 is a helper routine that allocates a new float64 value
		to store v and returns a pointer to it.

	 func GetBoolExtension(pb Message, extension *ExtensionDesc, ifnotset bool) bool
	 func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error)
		GetExtension retrieves a proto2 extended field from pb.
		
		If the descriptor is type complete (i.e., ExtensionDesc.ExtensionType is non-nil),
		then GetExtension parses the encoded field and returns a Go value of the specified type.
		If the field is not present, then the default value is returned (if one is specified),
		otherwise ErrMissingExtension is reported.
		
		If the descriptor is not type complete (i.e., ExtensionDesc.ExtensionType is nil),
		then GetExtension returns the raw encoded bytes of the field extension.

	 func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error)
		GetExtensions returns a slice of the extensions present in pb that are also listed in es.
		The returned slice has the same length as es; missing extensions will appear as nil elements.

	 func GetProperties(t reflect.Type) *StructProperties
		GetProperties returns the list of properties for the type represented by t.
		t must represent a generated struct type of a protocol message.

	 func GetRawExtension(m map[int32]Extension, id int32) ([]byte, error)
	 func GetStats() Stats
		Deprecated: do not use.

	 func GetUnsafeExtension(pb Message, fieldNum int32) (interface{}, error)
	 func GetUnsafeExtensionsMap(extendable Message) map[int32]Extension
	 func HasExtension(pb Message, extension *ExtensionDesc) bool
		HasExtension returns whether the given extension is present in pb.

	 func Int(v int) *int32
		Int is a helper routine that allocates a new int32 value
		to store v and returns a pointer to it, but unlike Int32
		its argument value is an int.

	 func Int32(v int32) *int32
		Int32 is a helper routine that allocates a new int32 value
		to store v and returns a pointer to it.

	 func Int64(v int64) *int64
		Int64 is a helper routine that allocates a new int64 value
		to store v and returns a pointer to it.

	 func Marshal(pb Message) ([]byte, error)
		Marshal takes a protocol buffer message
		and encodes it into the wire format, returning the data.
		This is the main entry point.

	 func MarshalJSONEnum(m map[int32]string, value int32) ([]byte, error)
	 func MarshalMessageSet(interface{}) ([]byte, error)
		Deprecated: do not use.

	 func MarshalMessageSetJSON(interface{}) ([]byte, error)
		Deprecated: do not use.

	 func MarshalText(w io.Writer, pb Message) error
		MarshalText writes a given protocol buffer in text format.
		The only errors returned are from w.

	 func MarshalTextString(pb Message) string
		MarshalTextString is the same as MarshalText, but returns the string directly.

	 func Merge(dst, src Message)
		Merge merges src into dst.
		Required and optional fields that are set in src will be set to that value in dst.
		Elements of repeated fields will be appended.
		Merge panics if src and dst are not the same type, or if dst is nil.

	 func MessageName(x Message) string
		MessageName returns the fully-qualified proto name for the given message type.

	 func MessageType(name string) reflect.Type
		MessageType returns the message type (pointer to struct) for a named message.
		The type is not guaranteed to implement proto.Message if the name refers to a
		map entry.

	 func NewBuffer(e []byte) *Buffer
		NewBuffer allocates a new Buffer and initializes its internal data to
		the contents of the argument slice.

	 func NewExtension(e []byte) Extension
	 func NewRequiredNotSetError(field string) *RequiredNotSetError
	 func NewUnsafeXXX_InternalExtensions(m map[int32]Extension) XXX_InternalExtensions
	 func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc
		RegisteredExtensions returns a map of the registered extensions of a
		protocol buffer struct, indexed by the extension number.
		The argument pb should be a nil pointer to the struct type.

	 func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32)
		RegisterEnum is called from the generated code to install the enum descriptor
		maps into the global table to aid parsing text format protocol buffers.

	 func RegisterExtension(desc *ExtensionDesc)
		RegisterExtension is called from the generated code.

	 func RegisterFile(filename string, fileDescriptor []byte)
		RegisterFile is called from generated code and maps from the
		full file name of a .proto file to its compressed FileDescriptorProto.

	 func RegisterMapType(x interface{}, name string)
		RegisterMapType is called from generated code and maps from the fully qualified
		proto name to the native map type of the proto map definition.

	 func RegisterMessageSetType(Message, int32, string)
		Deprecated: do not use.

	 func RegisterType(x Message, name string)
		RegisterType is called from generated code and maps from the fully qualified
		proto name to the type (pointer to struct) of the protocol buffer.

	 func SetDefaults(pb Message)
		SetDefaults sets unset protocol buffer fields to their default values.
		It only modifies fields that are both unset and have defined defaults.
		It recursively sets default values in any non-nil sub-messages.

	 func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error
		SetExtension sets the specified extension of pb to the specified value.

	 func SetRawExtension(base Message, id int32, b []byte)
		SetRawExtension is for testing only.

	 func SetUnsafeExtension(pb Message, fieldNum int32, value interface{}) error
	 func Size(pb Message) int
		Size returns the encoded size of a protocol buffer message.
		This is the main entry point.

	 func SizeOfInternalExtension(m extendableProto) (n int)
	 func SizeVarint(x uint64) int
		SizeVarint returns the varint encoding size of an integer.

	 func Skip(data []byte) (n int, err error)
	 func String(v string) *string
		String is a helper routine that allocates a new string value
		to store v and returns a pointer to it.

	 func StringFromExtensionsBytes(ext []byte) string
	 func StringFromExtensionsMap(m map[int32]Extension) string
	 func StringFromInternalExtension(m extendableProto) string
	 func Uint32(v uint32) *uint32
		Uint32 is a helper routine that allocates a new uint32 value
		to store v and returns a pointer to it.

	 func Uint64(v uint64) *uint64
		Uint64 is a helper routine that allocates a new uint64 value
		to store v and returns a pointer to it.

	 func Unmarshal(buf []byte, pb Message) error
		Unmarshal parses the protocol buffer representation in buf and places the
		decoded result in pb.  If the struct underlying pb does not match
		the data in buf, the results can be unpredictable.
		
		Unmarshal resets pb before starting to unmarshal, so any
		existing data in pb is always removed. Use UnmarshalMerge
		to preserve and append to existing data.

	 func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error)
		UnmarshalJSONEnum is a helper function to simplify recovering enum int values
		from their JSON-encoded representation. Given a map from the enum's symbolic
		names to its int values, and a byte buffer containing the JSON-encoded
		value, it returns an int32 that can be cast to the enum type by the caller.
		
		The function can deal with both JSON representations, numeric and symbolic.

	 func UnmarshalMerge(buf []byte, pb Message) error
		UnmarshalMerge parses the protocol buffer representation in buf and
		writes the decoded result to pb.  If the struct underlying pb does not match
		the data in buf, the results can be unpredictable.
		
		UnmarshalMerge merges into existing data in pb.
		Most code should use Unmarshal instead.

	 func UnmarshalMessageSet([]byte, interface{}) error
		Deprecated: do not use.

	 func UnmarshalMessageSetJSON([]byte, interface{}) error
		Deprecated: do not use.

	 func UnmarshalText(s string, pb Message) error
		UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
		before starting to unmarshal, so any existing data in pb is always removed.
		If a required field is not set and no other error occurs,
		UnmarshalText returns *RequiredNotSetError.


Package-Level Variables (total 4)

	  var ErrInternalBadWireType error
		ErrInternalBadWireType is returned by generated code when an incorrect
		wire type is encountered. It does not get returned to user code.

	  var ErrMissingExtension error
		ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message.

	  var ErrNil error
		ErrNil is the error returned if Marshal is called with nil.

	  var ErrTooLarge error
		ErrTooLarge is the error returned if Marshal is called with a
		message that encodes to >2GB.


Package-Level Constants (total 9)

	const GoGoProtoPackageIsVersion1 = true
		ProtoPackageIsVersion1 is referenced from generated protocol buffer files
		to assert that that code is compatible with this version of the proto package.

	const GoGoProtoPackageIsVersion2 = true
		ProtoPackageIsVersion2 is referenced from generated protocol buffer files
		to assert that that code is compatible with this version of the proto package.

	const GoGoProtoPackageIsVersion3 = true
		ProtoPackageIsVersion3 is referenced from generated protocol buffer files
		to assert that that code is compatible with this version of the proto package.

	const WireBytes = 2
		Constants that identify the encoding of a value on the wire.

	const WireEndGroup = 4
		Constants that identify the encoding of a value on the wire.

	const WireFixed32 = 5
		Constants that identify the encoding of a value on the wire.

	const WireFixed64 = 1
		Constants that identify the encoding of a value on the wire.

	const WireStartGroup = 3
		Constants that identify the encoding of a value on the wire.

	const WireVarint = 0
		Constants that identify the encoding of a value on the wire.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.