// Code generated by message-codegen. DO NOT EDIT.

package message

import (
	"fmt"
	"reflect"

	msgpb "github.com/milvus-io/milvus-proto/go-api/v2/msgpb"
	messagespb "github.com/milvus-io/milvus/pkg/v2/proto/messagespb"
)

// Export message types
const (
	MessageTypeUnknown          MessageType = MessageType(messagespb.MessageType_Unknown)
	MessageTypeTimeTick         MessageType = MessageType(messagespb.MessageType_TimeTick)
	MessageTypeInsert           MessageType = MessageType(messagespb.MessageType_Insert)
	MessageTypeDelete           MessageType = MessageType(messagespb.MessageType_Delete)
	MessageTypeCreateCollection MessageType = MessageType(messagespb.MessageType_CreateCollection)
	MessageTypeDropCollection   MessageType = MessageType(messagespb.MessageType_DropCollection)
	MessageTypeCreatePartition  MessageType = MessageType(messagespb.MessageType_CreatePartition)
	MessageTypeDropPartition    MessageType = MessageType(messagespb.MessageType_DropPartition)
	MessageTypeImport           MessageType = MessageType(messagespb.MessageType_Import)
	MessageTypeCreateSegment    MessageType = MessageType(messagespb.MessageType_CreateSegment)
	MessageTypeFlush            MessageType = MessageType(messagespb.MessageType_Flush)
	MessageTypeManualFlush      MessageType = MessageType(messagespb.MessageType_ManualFlush)
	MessageTypeBeginTxn         MessageType = MessageType(messagespb.MessageType_BeginTxn)
	MessageTypeCommitTxn        MessageType = MessageType(messagespb.MessageType_CommitTxn)
	MessageTypeRollbackTxn      MessageType = MessageType(messagespb.MessageType_RollbackTxn)
	MessageTypeTxn              MessageType = MessageType(messagespb.MessageType_Txn)
	MessageTypeSchemaChange     MessageType = MessageType(messagespb.MessageType_SchemaChange)
)

// Export extra message type
type (
	PartitionSegmentAssignment = messagespb.PartitionSegmentAssignment
	SegmentAssignment          = messagespb.SegmentAssignment
	ManualFlushExtraResponse   = messagespb.ManualFlushExtraResponse
)

// Export message header and body types
type (
	TimeTickMessageHeader         = messagespb.TimeTickMessageHeader
	TimeTickMsg                   = msgpb.TimeTickMsg
	InsertMessageHeader           = messagespb.InsertMessageHeader
	InsertRequest                 = msgpb.InsertRequest
	DeleteMessageHeader           = messagespb.DeleteMessageHeader
	DeleteRequest                 = msgpb.DeleteRequest
	CreateCollectionMessageHeader = messagespb.CreateCollectionMessageHeader
	CreateCollectionRequest       = msgpb.CreateCollectionRequest
	DropCollectionMessageHeader   = messagespb.DropCollectionMessageHeader
	DropCollectionRequest         = msgpb.DropCollectionRequest
	CreatePartitionMessageHeader  = messagespb.CreatePartitionMessageHeader
	CreatePartitionRequest        = msgpb.CreatePartitionRequest
	DropPartitionMessageHeader    = messagespb.DropPartitionMessageHeader
	DropPartitionRequest          = msgpb.DropPartitionRequest
	ImportMessageHeader           = messagespb.ImportMessageHeader
	ImportMsg                     = msgpb.ImportMsg
	CreateSegmentMessageHeader    = messagespb.CreateSegmentMessageHeader
	CreateSegmentMessageBody      = messagespb.CreateSegmentMessageBody
	FlushMessageHeader            = messagespb.FlushMessageHeader
	FlushMessageBody              = messagespb.FlushMessageBody
	ManualFlushMessageHeader      = messagespb.ManualFlushMessageHeader
	ManualFlushMessageBody        = messagespb.ManualFlushMessageBody
	BeginTxnMessageHeader         = messagespb.BeginTxnMessageHeader
	BeginTxnMessageBody           = messagespb.BeginTxnMessageBody
	CommitTxnMessageHeader        = messagespb.CommitTxnMessageHeader
	CommitTxnMessageBody          = messagespb.CommitTxnMessageBody
	RollbackTxnMessageHeader      = messagespb.RollbackTxnMessageHeader
	RollbackTxnMessageBody        = messagespb.RollbackTxnMessageBody
	TxnMessageHeader              = messagespb.TxnMessageHeader
	TxnMessageBody                = messagespb.TxnMessageBody
	SchemaChangeMessageHeader     = messagespb.SchemaChangeMessageHeader
	SchemaChangeMessageBody       = messagespb.SchemaChangeMessageBody
)

// Type aliases for TimeTickMessageV1
type (
	MutableTimeTickMessageV1   = specializedMutableMessage[*TimeTickMessageHeader, *TimeTickMsg]
	ImmutableTimeTickMessageV1 = SpecializedImmutableMessage[*TimeTickMessageHeader, *TimeTickMsg]
	BroadcastTimeTickMessageV1 = SpecializedBroadcastMessage[*TimeTickMessageHeader, *TimeTickMsg]
)

// MessageTypeWithVersion for TimeTickMessageV1
var MessageTypeTimeTickV1 = MessageTypeWithVersion{
	MessageType: MessageTypeTimeTick,
	Version:     VersionV1,
}

// MessageSpecializedType for TimeTickMessageV1
var SpecializedTypeTimeTickV1 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*TimeTickMsg)(nil)),
	HeaderType: reflect.TypeOf((*TimeTickMessageHeader)(nil)),
}

// AsMutableTimeTickMessageV1 converts a BasicMessage to MutableTimeTickMessageV1
var AsMutableTimeTickMessageV1 = asSpecializedMutableMessage[*TimeTickMessageHeader, *TimeTickMsg]

// MustAsMutableTimeTickMessageV1 converts a BasicMessage to MutableTimeTickMessageV1, panics on error
var MustAsMutableTimeTickMessageV1 = mustAsSpecializedMutableMessage[*TimeTickMessageHeader, *TimeTickMsg]

// AsImmutableTimeTickMessageV1 converts an ImmutableMessage to ImmutableTimeTickMessageV1
var AsImmutableTimeTickMessageV1 = asSpecializedImmutableMessage[*TimeTickMessageHeader, *TimeTickMsg]

// MustAsImmutableTimeTickMessageV1 converts an ImmutableMessage to ImmutableTimeTickMessageV1, panics on error
var MustAsImmutableTimeTickMessageV1 = MustAsSpecializedImmutableMessage[*TimeTickMessageHeader, *TimeTickMsg]

// AsBroadcastTimeTickMessageV1 converts a BasicMessage to BroadcastTimeTickMessageV1
var AsBroadcastTimeTickMessageV1 = asSpecializedBroadcastMessage[*TimeTickMessageHeader, *TimeTickMsg]

// MustAsBroadcastTimeTickMessageV1 converts a BasicMessage to BroadcastTimeTickMessageV1, panics on error
var MustAsBroadcastTimeTickMessageV1 = MustAsSpecializedBroadcastMessage[*TimeTickMessageHeader, *TimeTickMsg]

// NewTimeTickMessageBuilderV1 creates a new message builder for TimeTickMessageV1
var NewTimeTickMessageBuilderV1 = newMutableMessageBuilder[*TimeTickMessageHeader, *TimeTickMsg]

// Type aliases for InsertMessageV1
type (
	MutableInsertMessageV1   = specializedMutableMessage[*InsertMessageHeader, *InsertRequest]
	ImmutableInsertMessageV1 = SpecializedImmutableMessage[*InsertMessageHeader, *InsertRequest]
	BroadcastInsertMessageV1 = SpecializedBroadcastMessage[*InsertMessageHeader, *InsertRequest]
)

// MessageTypeWithVersion for InsertMessageV1
var MessageTypeInsertV1 = MessageTypeWithVersion{
	MessageType: MessageTypeInsert,
	Version:     VersionV1,
}

// MessageSpecializedType for InsertMessageV1
var SpecializedTypeInsertV1 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*InsertRequest)(nil)),
	HeaderType: reflect.TypeOf((*InsertMessageHeader)(nil)),
}

// AsMutableInsertMessageV1 converts a BasicMessage to MutableInsertMessageV1
var AsMutableInsertMessageV1 = asSpecializedMutableMessage[*InsertMessageHeader, *InsertRequest]

// MustAsMutableInsertMessageV1 converts a BasicMessage to MutableInsertMessageV1, panics on error
var MustAsMutableInsertMessageV1 = mustAsSpecializedMutableMessage[*InsertMessageHeader, *InsertRequest]

// AsImmutableInsertMessageV1 converts an ImmutableMessage to ImmutableInsertMessageV1
var AsImmutableInsertMessageV1 = asSpecializedImmutableMessage[*InsertMessageHeader, *InsertRequest]

// MustAsImmutableInsertMessageV1 converts an ImmutableMessage to ImmutableInsertMessageV1, panics on error
var MustAsImmutableInsertMessageV1 = MustAsSpecializedImmutableMessage[*InsertMessageHeader, *InsertRequest]

// AsBroadcastInsertMessageV1 converts a BasicMessage to BroadcastInsertMessageV1
var AsBroadcastInsertMessageV1 = asSpecializedBroadcastMessage[*InsertMessageHeader, *InsertRequest]

// MustAsBroadcastInsertMessageV1 converts a BasicMessage to BroadcastInsertMessageV1, panics on error
var MustAsBroadcastInsertMessageV1 = MustAsSpecializedBroadcastMessage[*InsertMessageHeader, *InsertRequest]

// NewInsertMessageBuilderV1 creates a new message builder for InsertMessageV1
var NewInsertMessageBuilderV1 = newMutableMessageBuilder[*InsertMessageHeader, *InsertRequest]

// Type aliases for DeleteMessageV1
type (
	MutableDeleteMessageV1   = specializedMutableMessage[*DeleteMessageHeader, *DeleteRequest]
	ImmutableDeleteMessageV1 = SpecializedImmutableMessage[*DeleteMessageHeader, *DeleteRequest]
	BroadcastDeleteMessageV1 = SpecializedBroadcastMessage[*DeleteMessageHeader, *DeleteRequest]
)

// MessageTypeWithVersion for DeleteMessageV1
var MessageTypeDeleteV1 = MessageTypeWithVersion{
	MessageType: MessageTypeDelete,
	Version:     VersionV1,
}

// MessageSpecializedType for DeleteMessageV1
var SpecializedTypeDeleteV1 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*DeleteRequest)(nil)),
	HeaderType: reflect.TypeOf((*DeleteMessageHeader)(nil)),
}

// AsMutableDeleteMessageV1 converts a BasicMessage to MutableDeleteMessageV1
var AsMutableDeleteMessageV1 = asSpecializedMutableMessage[*DeleteMessageHeader, *DeleteRequest]

// MustAsMutableDeleteMessageV1 converts a BasicMessage to MutableDeleteMessageV1, panics on error
var MustAsMutableDeleteMessageV1 = mustAsSpecializedMutableMessage[*DeleteMessageHeader, *DeleteRequest]

// AsImmutableDeleteMessageV1 converts an ImmutableMessage to ImmutableDeleteMessageV1
var AsImmutableDeleteMessageV1 = asSpecializedImmutableMessage[*DeleteMessageHeader, *DeleteRequest]

// MustAsImmutableDeleteMessageV1 converts an ImmutableMessage to ImmutableDeleteMessageV1, panics on error
var MustAsImmutableDeleteMessageV1 = MustAsSpecializedImmutableMessage[*DeleteMessageHeader, *DeleteRequest]

// AsBroadcastDeleteMessageV1 converts a BasicMessage to BroadcastDeleteMessageV1
var AsBroadcastDeleteMessageV1 = asSpecializedBroadcastMessage[*DeleteMessageHeader, *DeleteRequest]

// MustAsBroadcastDeleteMessageV1 converts a BasicMessage to BroadcastDeleteMessageV1, panics on error
var MustAsBroadcastDeleteMessageV1 = MustAsSpecializedBroadcastMessage[*DeleteMessageHeader, *DeleteRequest]

// NewDeleteMessageBuilderV1 creates a new message builder for DeleteMessageV1
var NewDeleteMessageBuilderV1 = newMutableMessageBuilder[*DeleteMessageHeader, *DeleteRequest]

// Type aliases for CreateCollectionMessageV1
type (
	MutableCreateCollectionMessageV1   = specializedMutableMessage[*CreateCollectionMessageHeader, *CreateCollectionRequest]
	ImmutableCreateCollectionMessageV1 = SpecializedImmutableMessage[*CreateCollectionMessageHeader, *CreateCollectionRequest]
	BroadcastCreateCollectionMessageV1 = SpecializedBroadcastMessage[*CreateCollectionMessageHeader, *CreateCollectionRequest]
)

// MessageTypeWithVersion for CreateCollectionMessageV1
var MessageTypeCreateCollectionV1 = MessageTypeWithVersion{
	MessageType: MessageTypeCreateCollection,
	Version:     VersionV1,
}

// MessageSpecializedType for CreateCollectionMessageV1
var SpecializedTypeCreateCollectionV1 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*CreateCollectionRequest)(nil)),
	HeaderType: reflect.TypeOf((*CreateCollectionMessageHeader)(nil)),
}

// AsMutableCreateCollectionMessageV1 converts a BasicMessage to MutableCreateCollectionMessageV1
var AsMutableCreateCollectionMessageV1 = asSpecializedMutableMessage[*CreateCollectionMessageHeader, *CreateCollectionRequest]

// MustAsMutableCreateCollectionMessageV1 converts a BasicMessage to MutableCreateCollectionMessageV1, panics on error
var MustAsMutableCreateCollectionMessageV1 = mustAsSpecializedMutableMessage[*CreateCollectionMessageHeader, *CreateCollectionRequest]

// AsImmutableCreateCollectionMessageV1 converts an ImmutableMessage to ImmutableCreateCollectionMessageV1
var AsImmutableCreateCollectionMessageV1 = asSpecializedImmutableMessage[*CreateCollectionMessageHeader, *CreateCollectionRequest]

// MustAsImmutableCreateCollectionMessageV1 converts an ImmutableMessage to ImmutableCreateCollectionMessageV1, panics on error
var MustAsImmutableCreateCollectionMessageV1 = MustAsSpecializedImmutableMessage[*CreateCollectionMessageHeader, *CreateCollectionRequest]

// AsBroadcastCreateCollectionMessageV1 converts a BasicMessage to BroadcastCreateCollectionMessageV1
var AsBroadcastCreateCollectionMessageV1 = asSpecializedBroadcastMessage[*CreateCollectionMessageHeader, *CreateCollectionRequest]

// MustAsBroadcastCreateCollectionMessageV1 converts a BasicMessage to BroadcastCreateCollectionMessageV1, panics on error
var MustAsBroadcastCreateCollectionMessageV1 = MustAsSpecializedBroadcastMessage[*CreateCollectionMessageHeader, *CreateCollectionRequest]

// NewCreateCollectionMessageBuilderV1 creates a new message builder for CreateCollectionMessageV1
var NewCreateCollectionMessageBuilderV1 = newMutableMessageBuilder[*CreateCollectionMessageHeader, *CreateCollectionRequest]

// Type aliases for DropCollectionMessageV1
type (
	MutableDropCollectionMessageV1   = specializedMutableMessage[*DropCollectionMessageHeader, *DropCollectionRequest]
	ImmutableDropCollectionMessageV1 = SpecializedImmutableMessage[*DropCollectionMessageHeader, *DropCollectionRequest]
	BroadcastDropCollectionMessageV1 = SpecializedBroadcastMessage[*DropCollectionMessageHeader, *DropCollectionRequest]
)

// MessageTypeWithVersion for DropCollectionMessageV1
var MessageTypeDropCollectionV1 = MessageTypeWithVersion{
	MessageType: MessageTypeDropCollection,
	Version:     VersionV1,
}

// MessageSpecializedType for DropCollectionMessageV1
var SpecializedTypeDropCollectionV1 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*DropCollectionRequest)(nil)),
	HeaderType: reflect.TypeOf((*DropCollectionMessageHeader)(nil)),
}

// AsMutableDropCollectionMessageV1 converts a BasicMessage to MutableDropCollectionMessageV1
var AsMutableDropCollectionMessageV1 = asSpecializedMutableMessage[*DropCollectionMessageHeader, *DropCollectionRequest]

// MustAsMutableDropCollectionMessageV1 converts a BasicMessage to MutableDropCollectionMessageV1, panics on error
var MustAsMutableDropCollectionMessageV1 = mustAsSpecializedMutableMessage[*DropCollectionMessageHeader, *DropCollectionRequest]

// AsImmutableDropCollectionMessageV1 converts an ImmutableMessage to ImmutableDropCollectionMessageV1
var AsImmutableDropCollectionMessageV1 = asSpecializedImmutableMessage[*DropCollectionMessageHeader, *DropCollectionRequest]

// MustAsImmutableDropCollectionMessageV1 converts an ImmutableMessage to ImmutableDropCollectionMessageV1, panics on error
var MustAsImmutableDropCollectionMessageV1 = MustAsSpecializedImmutableMessage[*DropCollectionMessageHeader, *DropCollectionRequest]

// AsBroadcastDropCollectionMessageV1 converts a BasicMessage to BroadcastDropCollectionMessageV1
var AsBroadcastDropCollectionMessageV1 = asSpecializedBroadcastMessage[*DropCollectionMessageHeader, *DropCollectionRequest]

// MustAsBroadcastDropCollectionMessageV1 converts a BasicMessage to BroadcastDropCollectionMessageV1, panics on error
var MustAsBroadcastDropCollectionMessageV1 = MustAsSpecializedBroadcastMessage[*DropCollectionMessageHeader, *DropCollectionRequest]

// NewDropCollectionMessageBuilderV1 creates a new message builder for DropCollectionMessageV1
var NewDropCollectionMessageBuilderV1 = newMutableMessageBuilder[*DropCollectionMessageHeader, *DropCollectionRequest]

// Type aliases for CreatePartitionMessageV1
type (
	MutableCreatePartitionMessageV1   = specializedMutableMessage[*CreatePartitionMessageHeader, *CreatePartitionRequest]
	ImmutableCreatePartitionMessageV1 = SpecializedImmutableMessage[*CreatePartitionMessageHeader, *CreatePartitionRequest]
	BroadcastCreatePartitionMessageV1 = SpecializedBroadcastMessage[*CreatePartitionMessageHeader, *CreatePartitionRequest]
)

// MessageTypeWithVersion for CreatePartitionMessageV1
var MessageTypeCreatePartitionV1 = MessageTypeWithVersion{
	MessageType: MessageTypeCreatePartition,
	Version:     VersionV1,
}

// MessageSpecializedType for CreatePartitionMessageV1
var SpecializedTypeCreatePartitionV1 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*CreatePartitionRequest)(nil)),
	HeaderType: reflect.TypeOf((*CreatePartitionMessageHeader)(nil)),
}

// AsMutableCreatePartitionMessageV1 converts a BasicMessage to MutableCreatePartitionMessageV1
var AsMutableCreatePartitionMessageV1 = asSpecializedMutableMessage[*CreatePartitionMessageHeader, *CreatePartitionRequest]

// MustAsMutableCreatePartitionMessageV1 converts a BasicMessage to MutableCreatePartitionMessageV1, panics on error
var MustAsMutableCreatePartitionMessageV1 = mustAsSpecializedMutableMessage[*CreatePartitionMessageHeader, *CreatePartitionRequest]

// AsImmutableCreatePartitionMessageV1 converts an ImmutableMessage to ImmutableCreatePartitionMessageV1
var AsImmutableCreatePartitionMessageV1 = asSpecializedImmutableMessage[*CreatePartitionMessageHeader, *CreatePartitionRequest]

// MustAsImmutableCreatePartitionMessageV1 converts an ImmutableMessage to ImmutableCreatePartitionMessageV1, panics on error
var MustAsImmutableCreatePartitionMessageV1 = MustAsSpecializedImmutableMessage[*CreatePartitionMessageHeader, *CreatePartitionRequest]

// AsBroadcastCreatePartitionMessageV1 converts a BasicMessage to BroadcastCreatePartitionMessageV1
var AsBroadcastCreatePartitionMessageV1 = asSpecializedBroadcastMessage[*CreatePartitionMessageHeader, *CreatePartitionRequest]

// MustAsBroadcastCreatePartitionMessageV1 converts a BasicMessage to BroadcastCreatePartitionMessageV1, panics on error
var MustAsBroadcastCreatePartitionMessageV1 = MustAsSpecializedBroadcastMessage[*CreatePartitionMessageHeader, *CreatePartitionRequest]

// NewCreatePartitionMessageBuilderV1 creates a new message builder for CreatePartitionMessageV1
var NewCreatePartitionMessageBuilderV1 = newMutableMessageBuilder[*CreatePartitionMessageHeader, *CreatePartitionRequest]

// Type aliases for DropPartitionMessageV1
type (
	MutableDropPartitionMessageV1   = specializedMutableMessage[*DropPartitionMessageHeader, *DropPartitionRequest]
	ImmutableDropPartitionMessageV1 = SpecializedImmutableMessage[*DropPartitionMessageHeader, *DropPartitionRequest]
	BroadcastDropPartitionMessageV1 = SpecializedBroadcastMessage[*DropPartitionMessageHeader, *DropPartitionRequest]
)

// MessageTypeWithVersion for DropPartitionMessageV1
var MessageTypeDropPartitionV1 = MessageTypeWithVersion{
	MessageType: MessageTypeDropPartition,
	Version:     VersionV1,
}

// MessageSpecializedType for DropPartitionMessageV1
var SpecializedTypeDropPartitionV1 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*DropPartitionRequest)(nil)),
	HeaderType: reflect.TypeOf((*DropPartitionMessageHeader)(nil)),
}

// AsMutableDropPartitionMessageV1 converts a BasicMessage to MutableDropPartitionMessageV1
var AsMutableDropPartitionMessageV1 = asSpecializedMutableMessage[*DropPartitionMessageHeader, *DropPartitionRequest]

// MustAsMutableDropPartitionMessageV1 converts a BasicMessage to MutableDropPartitionMessageV1, panics on error
var MustAsMutableDropPartitionMessageV1 = mustAsSpecializedMutableMessage[*DropPartitionMessageHeader, *DropPartitionRequest]

// AsImmutableDropPartitionMessageV1 converts an ImmutableMessage to ImmutableDropPartitionMessageV1
var AsImmutableDropPartitionMessageV1 = asSpecializedImmutableMessage[*DropPartitionMessageHeader, *DropPartitionRequest]

// MustAsImmutableDropPartitionMessageV1 converts an ImmutableMessage to ImmutableDropPartitionMessageV1, panics on error
var MustAsImmutableDropPartitionMessageV1 = MustAsSpecializedImmutableMessage[*DropPartitionMessageHeader, *DropPartitionRequest]

// AsBroadcastDropPartitionMessageV1 converts a BasicMessage to BroadcastDropPartitionMessageV1
var AsBroadcastDropPartitionMessageV1 = asSpecializedBroadcastMessage[*DropPartitionMessageHeader, *DropPartitionRequest]

// MustAsBroadcastDropPartitionMessageV1 converts a BasicMessage to BroadcastDropPartitionMessageV1, panics on error
var MustAsBroadcastDropPartitionMessageV1 = MustAsSpecializedBroadcastMessage[*DropPartitionMessageHeader, *DropPartitionRequest]

// NewDropPartitionMessageBuilderV1 creates a new message builder for DropPartitionMessageV1
var NewDropPartitionMessageBuilderV1 = newMutableMessageBuilder[*DropPartitionMessageHeader, *DropPartitionRequest]

// Type aliases for ImportMessageV1
type (
	MutableImportMessageV1   = specializedMutableMessage[*ImportMessageHeader, *ImportMsg]
	ImmutableImportMessageV1 = SpecializedImmutableMessage[*ImportMessageHeader, *ImportMsg]
	BroadcastImportMessageV1 = SpecializedBroadcastMessage[*ImportMessageHeader, *ImportMsg]
)

// MessageTypeWithVersion for ImportMessageV1
var MessageTypeImportV1 = MessageTypeWithVersion{
	MessageType: MessageTypeImport,
	Version:     VersionV1,
}

// MessageSpecializedType for ImportMessageV1
var SpecializedTypeImportV1 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*ImportMsg)(nil)),
	HeaderType: reflect.TypeOf((*ImportMessageHeader)(nil)),
}

// AsMutableImportMessageV1 converts a BasicMessage to MutableImportMessageV1
var AsMutableImportMessageV1 = asSpecializedMutableMessage[*ImportMessageHeader, *ImportMsg]

// MustAsMutableImportMessageV1 converts a BasicMessage to MutableImportMessageV1, panics on error
var MustAsMutableImportMessageV1 = mustAsSpecializedMutableMessage[*ImportMessageHeader, *ImportMsg]

// AsImmutableImportMessageV1 converts an ImmutableMessage to ImmutableImportMessageV1
var AsImmutableImportMessageV1 = asSpecializedImmutableMessage[*ImportMessageHeader, *ImportMsg]

// MustAsImmutableImportMessageV1 converts an ImmutableMessage to ImmutableImportMessageV1, panics on error
var MustAsImmutableImportMessageV1 = MustAsSpecializedImmutableMessage[*ImportMessageHeader, *ImportMsg]

// AsBroadcastImportMessageV1 converts a BasicMessage to BroadcastImportMessageV1
var AsBroadcastImportMessageV1 = asSpecializedBroadcastMessage[*ImportMessageHeader, *ImportMsg]

// MustAsBroadcastImportMessageV1 converts a BasicMessage to BroadcastImportMessageV1, panics on error
var MustAsBroadcastImportMessageV1 = MustAsSpecializedBroadcastMessage[*ImportMessageHeader, *ImportMsg]

// NewImportMessageBuilderV1 creates a new message builder for ImportMessageV1
var NewImportMessageBuilderV1 = newMutableMessageBuilder[*ImportMessageHeader, *ImportMsg]

// Type aliases for CreateSegmentMessageV2
type (
	MutableCreateSegmentMessageV2   = specializedMutableMessage[*CreateSegmentMessageHeader, *CreateSegmentMessageBody]
	ImmutableCreateSegmentMessageV2 = SpecializedImmutableMessage[*CreateSegmentMessageHeader, *CreateSegmentMessageBody]
	BroadcastCreateSegmentMessageV2 = SpecializedBroadcastMessage[*CreateSegmentMessageHeader, *CreateSegmentMessageBody]
)

// MessageTypeWithVersion for CreateSegmentMessageV2
var MessageTypeCreateSegmentV2 = MessageTypeWithVersion{
	MessageType: MessageTypeCreateSegment,
	Version:     VersionV2,
}

// MessageSpecializedType for CreateSegmentMessageV2
var SpecializedTypeCreateSegmentV2 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*CreateSegmentMessageBody)(nil)),
	HeaderType: reflect.TypeOf((*CreateSegmentMessageHeader)(nil)),
}

// AsMutableCreateSegmentMessageV2 converts a BasicMessage to MutableCreateSegmentMessageV2
var AsMutableCreateSegmentMessageV2 = asSpecializedMutableMessage[*CreateSegmentMessageHeader, *CreateSegmentMessageBody]

// MustAsMutableCreateSegmentMessageV2 converts a BasicMessage to MutableCreateSegmentMessageV2, panics on error
var MustAsMutableCreateSegmentMessageV2 = mustAsSpecializedMutableMessage[*CreateSegmentMessageHeader, *CreateSegmentMessageBody]

// AsImmutableCreateSegmentMessageV2 converts an ImmutableMessage to ImmutableCreateSegmentMessageV2
var AsImmutableCreateSegmentMessageV2 = asSpecializedImmutableMessage[*CreateSegmentMessageHeader, *CreateSegmentMessageBody]

// MustAsImmutableCreateSegmentMessageV2 converts an ImmutableMessage to ImmutableCreateSegmentMessageV2, panics on error
var MustAsImmutableCreateSegmentMessageV2 = MustAsSpecializedImmutableMessage[*CreateSegmentMessageHeader, *CreateSegmentMessageBody]

// AsBroadcastCreateSegmentMessageV2 converts a BasicMessage to BroadcastCreateSegmentMessageV2
var AsBroadcastCreateSegmentMessageV2 = asSpecializedBroadcastMessage[*CreateSegmentMessageHeader, *CreateSegmentMessageBody]

// MustAsBroadcastCreateSegmentMessageV2 converts a BasicMessage to BroadcastCreateSegmentMessageV2, panics on error
var MustAsBroadcastCreateSegmentMessageV2 = MustAsSpecializedBroadcastMessage[*CreateSegmentMessageHeader, *CreateSegmentMessageBody]

// NewCreateSegmentMessageBuilderV2 creates a new message builder for CreateSegmentMessageV2
var NewCreateSegmentMessageBuilderV2 = newMutableMessageBuilder[*CreateSegmentMessageHeader, *CreateSegmentMessageBody]

// Type aliases for FlushMessageV2
type (
	MutableFlushMessageV2   = specializedMutableMessage[*FlushMessageHeader, *FlushMessageBody]
	ImmutableFlushMessageV2 = SpecializedImmutableMessage[*FlushMessageHeader, *FlushMessageBody]
	BroadcastFlushMessageV2 = SpecializedBroadcastMessage[*FlushMessageHeader, *FlushMessageBody]
)

// MessageTypeWithVersion for FlushMessageV2
var MessageTypeFlushV2 = MessageTypeWithVersion{
	MessageType: MessageTypeFlush,
	Version:     VersionV2,
}

// MessageSpecializedType for FlushMessageV2
var SpecializedTypeFlushV2 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*FlushMessageBody)(nil)),
	HeaderType: reflect.TypeOf((*FlushMessageHeader)(nil)),
}

// AsMutableFlushMessageV2 converts a BasicMessage to MutableFlushMessageV2
var AsMutableFlushMessageV2 = asSpecializedMutableMessage[*FlushMessageHeader, *FlushMessageBody]

// MustAsMutableFlushMessageV2 converts a BasicMessage to MutableFlushMessageV2, panics on error
var MustAsMutableFlushMessageV2 = mustAsSpecializedMutableMessage[*FlushMessageHeader, *FlushMessageBody]

// AsImmutableFlushMessageV2 converts an ImmutableMessage to ImmutableFlushMessageV2
var AsImmutableFlushMessageV2 = asSpecializedImmutableMessage[*FlushMessageHeader, *FlushMessageBody]

// MustAsImmutableFlushMessageV2 converts an ImmutableMessage to ImmutableFlushMessageV2, panics on error
var MustAsImmutableFlushMessageV2 = MustAsSpecializedImmutableMessage[*FlushMessageHeader, *FlushMessageBody]

// AsBroadcastFlushMessageV2 converts a BasicMessage to BroadcastFlushMessageV2
var AsBroadcastFlushMessageV2 = asSpecializedBroadcastMessage[*FlushMessageHeader, *FlushMessageBody]

// MustAsBroadcastFlushMessageV2 converts a BasicMessage to BroadcastFlushMessageV2, panics on error
var MustAsBroadcastFlushMessageV2 = MustAsSpecializedBroadcastMessage[*FlushMessageHeader, *FlushMessageBody]

// NewFlushMessageBuilderV2 creates a new message builder for FlushMessageV2
var NewFlushMessageBuilderV2 = newMutableMessageBuilder[*FlushMessageHeader, *FlushMessageBody]

// Type aliases for ManualFlushMessageV2
type (
	MutableManualFlushMessageV2   = specializedMutableMessage[*ManualFlushMessageHeader, *ManualFlushMessageBody]
	ImmutableManualFlushMessageV2 = SpecializedImmutableMessage[*ManualFlushMessageHeader, *ManualFlushMessageBody]
	BroadcastManualFlushMessageV2 = SpecializedBroadcastMessage[*ManualFlushMessageHeader, *ManualFlushMessageBody]
)

// MessageTypeWithVersion for ManualFlushMessageV2
var MessageTypeManualFlushV2 = MessageTypeWithVersion{
	MessageType: MessageTypeManualFlush,
	Version:     VersionV2,
}

// MessageSpecializedType for ManualFlushMessageV2
var SpecializedTypeManualFlushV2 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*ManualFlushMessageBody)(nil)),
	HeaderType: reflect.TypeOf((*ManualFlushMessageHeader)(nil)),
}

// AsMutableManualFlushMessageV2 converts a BasicMessage to MutableManualFlushMessageV2
var AsMutableManualFlushMessageV2 = asSpecializedMutableMessage[*ManualFlushMessageHeader, *ManualFlushMessageBody]

// MustAsMutableManualFlushMessageV2 converts a BasicMessage to MutableManualFlushMessageV2, panics on error
var MustAsMutableManualFlushMessageV2 = mustAsSpecializedMutableMessage[*ManualFlushMessageHeader, *ManualFlushMessageBody]

// AsImmutableManualFlushMessageV2 converts an ImmutableMessage to ImmutableManualFlushMessageV2
var AsImmutableManualFlushMessageV2 = asSpecializedImmutableMessage[*ManualFlushMessageHeader, *ManualFlushMessageBody]

// MustAsImmutableManualFlushMessageV2 converts an ImmutableMessage to ImmutableManualFlushMessageV2, panics on error
var MustAsImmutableManualFlushMessageV2 = MustAsSpecializedImmutableMessage[*ManualFlushMessageHeader, *ManualFlushMessageBody]

// AsBroadcastManualFlushMessageV2 converts a BasicMessage to BroadcastManualFlushMessageV2
var AsBroadcastManualFlushMessageV2 = asSpecializedBroadcastMessage[*ManualFlushMessageHeader, *ManualFlushMessageBody]

// MustAsBroadcastManualFlushMessageV2 converts a BasicMessage to BroadcastManualFlushMessageV2, panics on error
var MustAsBroadcastManualFlushMessageV2 = MustAsSpecializedBroadcastMessage[*ManualFlushMessageHeader, *ManualFlushMessageBody]

// NewManualFlushMessageBuilderV2 creates a new message builder for ManualFlushMessageV2
var NewManualFlushMessageBuilderV2 = newMutableMessageBuilder[*ManualFlushMessageHeader, *ManualFlushMessageBody]

// Type aliases for BeginTxnMessageV2
type (
	MutableBeginTxnMessageV2   = specializedMutableMessage[*BeginTxnMessageHeader, *BeginTxnMessageBody]
	ImmutableBeginTxnMessageV2 = SpecializedImmutableMessage[*BeginTxnMessageHeader, *BeginTxnMessageBody]
	BroadcastBeginTxnMessageV2 = SpecializedBroadcastMessage[*BeginTxnMessageHeader, *BeginTxnMessageBody]
)

// MessageTypeWithVersion for BeginTxnMessageV2
var MessageTypeBeginTxnV2 = MessageTypeWithVersion{
	MessageType: MessageTypeBeginTxn,
	Version:     VersionV2,
}

// MessageSpecializedType for BeginTxnMessageV2
var SpecializedTypeBeginTxnV2 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*BeginTxnMessageBody)(nil)),
	HeaderType: reflect.TypeOf((*BeginTxnMessageHeader)(nil)),
}

// AsMutableBeginTxnMessageV2 converts a BasicMessage to MutableBeginTxnMessageV2
var AsMutableBeginTxnMessageV2 = asSpecializedMutableMessage[*BeginTxnMessageHeader, *BeginTxnMessageBody]

// MustAsMutableBeginTxnMessageV2 converts a BasicMessage to MutableBeginTxnMessageV2, panics on error
var MustAsMutableBeginTxnMessageV2 = mustAsSpecializedMutableMessage[*BeginTxnMessageHeader, *BeginTxnMessageBody]

// AsImmutableBeginTxnMessageV2 converts an ImmutableMessage to ImmutableBeginTxnMessageV2
var AsImmutableBeginTxnMessageV2 = asSpecializedImmutableMessage[*BeginTxnMessageHeader, *BeginTxnMessageBody]

// MustAsImmutableBeginTxnMessageV2 converts an ImmutableMessage to ImmutableBeginTxnMessageV2, panics on error
var MustAsImmutableBeginTxnMessageV2 = MustAsSpecializedImmutableMessage[*BeginTxnMessageHeader, *BeginTxnMessageBody]

// AsBroadcastBeginTxnMessageV2 converts a BasicMessage to BroadcastBeginTxnMessageV2
var AsBroadcastBeginTxnMessageV2 = asSpecializedBroadcastMessage[*BeginTxnMessageHeader, *BeginTxnMessageBody]

// MustAsBroadcastBeginTxnMessageV2 converts a BasicMessage to BroadcastBeginTxnMessageV2, panics on error
var MustAsBroadcastBeginTxnMessageV2 = MustAsSpecializedBroadcastMessage[*BeginTxnMessageHeader, *BeginTxnMessageBody]

// NewBeginTxnMessageBuilderV2 creates a new message builder for BeginTxnMessageV2
var NewBeginTxnMessageBuilderV2 = newMutableMessageBuilder[*BeginTxnMessageHeader, *BeginTxnMessageBody]

// Type aliases for CommitTxnMessageV2
type (
	MutableCommitTxnMessageV2   = specializedMutableMessage[*CommitTxnMessageHeader, *CommitTxnMessageBody]
	ImmutableCommitTxnMessageV2 = SpecializedImmutableMessage[*CommitTxnMessageHeader, *CommitTxnMessageBody]
	BroadcastCommitTxnMessageV2 = SpecializedBroadcastMessage[*CommitTxnMessageHeader, *CommitTxnMessageBody]
)

// MessageTypeWithVersion for CommitTxnMessageV2
var MessageTypeCommitTxnV2 = MessageTypeWithVersion{
	MessageType: MessageTypeCommitTxn,
	Version:     VersionV2,
}

// MessageSpecializedType for CommitTxnMessageV2
var SpecializedTypeCommitTxnV2 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*CommitTxnMessageBody)(nil)),
	HeaderType: reflect.TypeOf((*CommitTxnMessageHeader)(nil)),
}

// AsMutableCommitTxnMessageV2 converts a BasicMessage to MutableCommitTxnMessageV2
var AsMutableCommitTxnMessageV2 = asSpecializedMutableMessage[*CommitTxnMessageHeader, *CommitTxnMessageBody]

// MustAsMutableCommitTxnMessageV2 converts a BasicMessage to MutableCommitTxnMessageV2, panics on error
var MustAsMutableCommitTxnMessageV2 = mustAsSpecializedMutableMessage[*CommitTxnMessageHeader, *CommitTxnMessageBody]

// AsImmutableCommitTxnMessageV2 converts an ImmutableMessage to ImmutableCommitTxnMessageV2
var AsImmutableCommitTxnMessageV2 = asSpecializedImmutableMessage[*CommitTxnMessageHeader, *CommitTxnMessageBody]

// MustAsImmutableCommitTxnMessageV2 converts an ImmutableMessage to ImmutableCommitTxnMessageV2, panics on error
var MustAsImmutableCommitTxnMessageV2 = MustAsSpecializedImmutableMessage[*CommitTxnMessageHeader, *CommitTxnMessageBody]

// AsBroadcastCommitTxnMessageV2 converts a BasicMessage to BroadcastCommitTxnMessageV2
var AsBroadcastCommitTxnMessageV2 = asSpecializedBroadcastMessage[*CommitTxnMessageHeader, *CommitTxnMessageBody]

// MustAsBroadcastCommitTxnMessageV2 converts a BasicMessage to BroadcastCommitTxnMessageV2, panics on error
var MustAsBroadcastCommitTxnMessageV2 = MustAsSpecializedBroadcastMessage[*CommitTxnMessageHeader, *CommitTxnMessageBody]

// NewCommitTxnMessageBuilderV2 creates a new message builder for CommitTxnMessageV2
var NewCommitTxnMessageBuilderV2 = newMutableMessageBuilder[*CommitTxnMessageHeader, *CommitTxnMessageBody]

// Type aliases for RollbackTxnMessageV2
type (
	MutableRollbackTxnMessageV2   = specializedMutableMessage[*RollbackTxnMessageHeader, *RollbackTxnMessageBody]
	ImmutableRollbackTxnMessageV2 = SpecializedImmutableMessage[*RollbackTxnMessageHeader, *RollbackTxnMessageBody]
	BroadcastRollbackTxnMessageV2 = SpecializedBroadcastMessage[*RollbackTxnMessageHeader, *RollbackTxnMessageBody]
)

// MessageTypeWithVersion for RollbackTxnMessageV2
var MessageTypeRollbackTxnV2 = MessageTypeWithVersion{
	MessageType: MessageTypeRollbackTxn,
	Version:     VersionV2,
}

// MessageSpecializedType for RollbackTxnMessageV2
var SpecializedTypeRollbackTxnV2 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*RollbackTxnMessageBody)(nil)),
	HeaderType: reflect.TypeOf((*RollbackTxnMessageHeader)(nil)),
}

// AsMutableRollbackTxnMessageV2 converts a BasicMessage to MutableRollbackTxnMessageV2
var AsMutableRollbackTxnMessageV2 = asSpecializedMutableMessage[*RollbackTxnMessageHeader, *RollbackTxnMessageBody]

// MustAsMutableRollbackTxnMessageV2 converts a BasicMessage to MutableRollbackTxnMessageV2, panics on error
var MustAsMutableRollbackTxnMessageV2 = mustAsSpecializedMutableMessage[*RollbackTxnMessageHeader, *RollbackTxnMessageBody]

// AsImmutableRollbackTxnMessageV2 converts an ImmutableMessage to ImmutableRollbackTxnMessageV2
var AsImmutableRollbackTxnMessageV2 = asSpecializedImmutableMessage[*RollbackTxnMessageHeader, *RollbackTxnMessageBody]

// MustAsImmutableRollbackTxnMessageV2 converts an ImmutableMessage to ImmutableRollbackTxnMessageV2, panics on error
var MustAsImmutableRollbackTxnMessageV2 = MustAsSpecializedImmutableMessage[*RollbackTxnMessageHeader, *RollbackTxnMessageBody]

// AsBroadcastRollbackTxnMessageV2 converts a BasicMessage to BroadcastRollbackTxnMessageV2
var AsBroadcastRollbackTxnMessageV2 = asSpecializedBroadcastMessage[*RollbackTxnMessageHeader, *RollbackTxnMessageBody]

// MustAsBroadcastRollbackTxnMessageV2 converts a BasicMessage to BroadcastRollbackTxnMessageV2, panics on error
var MustAsBroadcastRollbackTxnMessageV2 = MustAsSpecializedBroadcastMessage[*RollbackTxnMessageHeader, *RollbackTxnMessageBody]

// NewRollbackTxnMessageBuilderV2 creates a new message builder for RollbackTxnMessageV2
var NewRollbackTxnMessageBuilderV2 = newMutableMessageBuilder[*RollbackTxnMessageHeader, *RollbackTxnMessageBody]

// Type aliases for TxnMessageV2
type (
	MutableTxnMessageV2   = specializedMutableMessage[*TxnMessageHeader, *TxnMessageBody]
	ImmutableTxnMessageV2 = SpecializedImmutableMessage[*TxnMessageHeader, *TxnMessageBody]
	BroadcastTxnMessageV2 = SpecializedBroadcastMessage[*TxnMessageHeader, *TxnMessageBody]
)

// MessageTypeWithVersion for TxnMessageV2
var MessageTypeTxnV2 = MessageTypeWithVersion{
	MessageType: MessageTypeTxn,
	Version:     VersionV2,
}

// MessageSpecializedType for TxnMessageV2
var SpecializedTypeTxnV2 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*TxnMessageBody)(nil)),
	HeaderType: reflect.TypeOf((*TxnMessageHeader)(nil)),
}

// Type aliases for SchemaChangeMessageV2
type (
	MutableSchemaChangeMessageV2   = specializedMutableMessage[*SchemaChangeMessageHeader, *SchemaChangeMessageBody]
	ImmutableSchemaChangeMessageV2 = SpecializedImmutableMessage[*SchemaChangeMessageHeader, *SchemaChangeMessageBody]
	BroadcastSchemaChangeMessageV2 = SpecializedBroadcastMessage[*SchemaChangeMessageHeader, *SchemaChangeMessageBody]
)

// MessageTypeWithVersion for SchemaChangeMessageV2
var MessageTypeSchemaChangeV2 = MessageTypeWithVersion{
	MessageType: MessageTypeSchemaChange,
	Version:     VersionV2,
}

// MessageSpecializedType for SchemaChangeMessageV2
var SpecializedTypeSchemaChangeV2 = MessageSpecializedType{
	BodyType:   reflect.TypeOf((*SchemaChangeMessageBody)(nil)),
	HeaderType: reflect.TypeOf((*SchemaChangeMessageHeader)(nil)),
}

// AsMutableSchemaChangeMessageV2 converts a BasicMessage to MutableSchemaChangeMessageV2
var AsMutableSchemaChangeMessageV2 = asSpecializedMutableMessage[*SchemaChangeMessageHeader, *SchemaChangeMessageBody]

// MustAsMutableSchemaChangeMessageV2 converts a BasicMessage to MutableSchemaChangeMessageV2, panics on error
var MustAsMutableSchemaChangeMessageV2 = mustAsSpecializedMutableMessage[*SchemaChangeMessageHeader, *SchemaChangeMessageBody]

// AsImmutableSchemaChangeMessageV2 converts an ImmutableMessage to ImmutableSchemaChangeMessageV2
var AsImmutableSchemaChangeMessageV2 = asSpecializedImmutableMessage[*SchemaChangeMessageHeader, *SchemaChangeMessageBody]

// MustAsImmutableSchemaChangeMessageV2 converts an ImmutableMessage to ImmutableSchemaChangeMessageV2, panics on error
var MustAsImmutableSchemaChangeMessageV2 = MustAsSpecializedImmutableMessage[*SchemaChangeMessageHeader, *SchemaChangeMessageBody]

// AsBroadcastSchemaChangeMessageV2 converts a BasicMessage to BroadcastSchemaChangeMessageV2
var AsBroadcastSchemaChangeMessageV2 = asSpecializedBroadcastMessage[*SchemaChangeMessageHeader, *SchemaChangeMessageBody]

// MustAsBroadcastSchemaChangeMessageV2 converts a BasicMessage to BroadcastSchemaChangeMessageV2, panics on error
var MustAsBroadcastSchemaChangeMessageV2 = MustAsSpecializedBroadcastMessage[*SchemaChangeMessageHeader, *SchemaChangeMessageBody]

// NewSchemaChangeMessageBuilderV2 creates a new message builder for SchemaChangeMessageV2
var NewSchemaChangeMessageBuilderV2 = newMutableMessageBuilder[*SchemaChangeMessageHeader, *SchemaChangeMessageBody]

// messageTypeMap make the contriants that one header type can only be used for one message type.
var messageTypeMap = map[reflect.Type]MessageType{
	reflect.TypeOf(&messagespb.BeginTxnMessageHeader{}):         MessageTypeBeginTxn,
	reflect.TypeOf(&messagespb.CommitTxnMessageHeader{}):        MessageTypeCommitTxn,
	reflect.TypeOf(&messagespb.CreateCollectionMessageHeader{}): MessageTypeCreateCollection,
	reflect.TypeOf(&messagespb.CreatePartitionMessageHeader{}):  MessageTypeCreatePartition,
	reflect.TypeOf(&messagespb.CreateSegmentMessageHeader{}):    MessageTypeCreateSegment,
	reflect.TypeOf(&messagespb.DeleteMessageHeader{}):           MessageTypeDelete,
	reflect.TypeOf(&messagespb.DropCollectionMessageHeader{}):   MessageTypeDropCollection,
	reflect.TypeOf(&messagespb.DropPartitionMessageHeader{}):    MessageTypeDropPartition,
	reflect.TypeOf(&messagespb.FlushMessageHeader{}):            MessageTypeFlush,
	reflect.TypeOf(&messagespb.ImportMessageHeader{}):           MessageTypeImport,
	reflect.TypeOf(&messagespb.InsertMessageHeader{}):           MessageTypeInsert,
	reflect.TypeOf(&messagespb.ManualFlushMessageHeader{}):      MessageTypeManualFlush,
	reflect.TypeOf(&messagespb.RollbackTxnMessageHeader{}):      MessageTypeRollbackTxn,
	reflect.TypeOf(&messagespb.SchemaChangeMessageHeader{}):     MessageTypeSchemaChange,
	reflect.TypeOf(&messagespb.TimeTickMessageHeader{}):         MessageTypeTimeTick,
	reflect.TypeOf(&messagespb.TxnMessageHeader{}):              MessageTypeTxn,
}

// MessageTypeWithVersion identifies a message type and version
type MessageTypeWithVersion struct {
	MessageType MessageType
	Version     Version
}

func (m MessageTypeWithVersion) String() string {
	return fmt.Sprintf("%s@v%d", m.MessageType.String(), m.Version)
}

// MessageSpecializedType contains reflection types for message headers and bodies
type MessageSpecializedType struct {
	HeaderType reflect.Type
	BodyType   reflect.Type
}

// messageTypeVersionSpecializedMap maps MessageTypeWithVersion to MessageSpecializedType
var messageTypeVersionSpecializedMap = map[MessageTypeWithVersion]MessageSpecializedType{
	MessageTypeBeginTxnV2:         SpecializedTypeBeginTxnV2,
	MessageTypeCommitTxnV2:        SpecializedTypeCommitTxnV2,
	MessageTypeCreateCollectionV1: SpecializedTypeCreateCollectionV1,
	MessageTypeCreatePartitionV1:  SpecializedTypeCreatePartitionV1,
	MessageTypeCreateSegmentV2:    SpecializedTypeCreateSegmentV2,
	MessageTypeDeleteV1:           SpecializedTypeDeleteV1,
	MessageTypeDropCollectionV1:   SpecializedTypeDropCollectionV1,
	MessageTypeDropPartitionV1:    SpecializedTypeDropPartitionV1,
	MessageTypeFlushV2:            SpecializedTypeFlushV2,
	MessageTypeImportV1:           SpecializedTypeImportV1,
	MessageTypeInsertV1:           SpecializedTypeInsertV1,
	MessageTypeManualFlushV2:      SpecializedTypeManualFlushV2,
	MessageTypeRollbackTxnV2:      SpecializedTypeRollbackTxnV2,
	MessageTypeSchemaChangeV2:     SpecializedTypeSchemaChangeV2,
	MessageTypeTimeTickV1:         SpecializedTypeTimeTickV1,
	MessageTypeTxnV2:              SpecializedTypeTxnV2,
}

// messageSpecializedTypeVersionMap maps MessageSpecializedType to MessageTypeWithVersion
var messageSpecializedTypeVersionMap = map[MessageSpecializedType]MessageTypeWithVersion{
	SpecializedTypeBeginTxnV2:         MessageTypeBeginTxnV2,
	SpecializedTypeCommitTxnV2:        MessageTypeCommitTxnV2,
	SpecializedTypeCreateCollectionV1: MessageTypeCreateCollectionV1,
	SpecializedTypeCreatePartitionV1:  MessageTypeCreatePartitionV1,
	SpecializedTypeCreateSegmentV2:    MessageTypeCreateSegmentV2,
	SpecializedTypeDeleteV1:           MessageTypeDeleteV1,
	SpecializedTypeDropCollectionV1:   MessageTypeDropCollectionV1,
	SpecializedTypeDropPartitionV1:    MessageTypeDropPartitionV1,
	SpecializedTypeFlushV2:            MessageTypeFlushV2,
	SpecializedTypeImportV1:           MessageTypeImportV1,
	SpecializedTypeInsertV1:           MessageTypeInsertV1,
	SpecializedTypeManualFlushV2:      MessageTypeManualFlushV2,
	SpecializedTypeRollbackTxnV2:      MessageTypeRollbackTxnV2,
	SpecializedTypeSchemaChangeV2:     MessageTypeSchemaChangeV2,
	SpecializedTypeTimeTickV1:         MessageTypeTimeTickV1,
	SpecializedTypeTxnV2:              MessageTypeTxnV2,
}