winmd

type Assembly struct {
	HashAlgID      flags.AssemblyHashAlgorithm
	MajorVersion   uint16
	MinorVersion   uint16
	BuildNumber    uint16
	RevisionNumber uint16
	Flags          flags.AssemblyFlags
	PublicKey      []byte
	Name           String
	Culture        String
}

type AssemblyRef struct {
	MajorVersion     uint16
	MinorVersion     uint16
	BuildNumber      uint16
	RevisionNumber   uint16
	Flags            flags.AssemblyFlags
	PublicKeyOrToken []byte
	Name             String
	Culture          String
	HashValue        []byte
}

type BlobHeap []byte

type ClassLayout struct {
	PackingSize uint16
	ClassSize   uint32
	Parent      Index // @ref=TypeDef
}

type CodedIndex struct {
	Index Index
	Tag   int8
}

type Constant struct {
	Type    flags.ElementType
	Padding byte       // 1-byte padding zero
	Parent  CodedIndex // @code=HasConstant
	Value   []byte
}

type CustomAttribute struct {
	Parent CodedIndex // @code=HasCustomAttribute
	Type   CodedIndex // @code=CustomAttributeType
	Value  []byte
}

type DeclSecurity struct {
	Action        uint16
	Parent        CodedIndex // @code=HasDeclSecurity
	PermissionSet []byte
}

type Event struct {
	EventFlags flags.EventAttributes
	Name       String
	EventType  CodedIndex // @code=TypeDefOrRef
}

type EventMap struct {
	Parent    Index // @ref=TypeDef
	EventList Slice // @ref=Event
}

type ExportedType struct {
	Flags          flags.TypeAttributes
	TypeDefID      uint32 // index into a TypeDef table, used as hint only
	Name           String
	Namespace      String
	Implementation CodedIndex // @code=Implementation
}

type Field struct {
	Flags     flags.FieldAttributes
	Name      String
	Signature SigFieldBlob
}

type FieldLayout struct {
	Offset uint32
	Field  Index // @ref=Field
}

type FieldMarshal struct {
	Parent     CodedIndex // @code=HasFieldMarshal
	NativeType []byte
}

type FieldRVA struct {
	RVA   uint32
	Field Index // @ref=Field
}

type File struct {
	Flags     flags.FileAttributes
	Name      String
	HashValue []byte
}

type GUIDHeap []byte

type GenericParam struct {
	Number uint16
	Flags  flags.GenericParamAttributes
	Owner  CodedIndex // @code=TypeOrMethodDef
	Name   String
}

type GenericParamConstraint struct {
	Owner      Index      // @ref=GenericParam
	Constraint CodedIndex // @code=TypeDefOrRef
}

type ImplMap struct {
	MappingFlags    flags.PInvokeAttributes
	MemberForwarded CodedIndex // @code=MemberForwarded
	ImportName      String
	ImportScope     Index // @ref=ModuleRef
}

type Index uint32

type InterfaceImpl struct {
	Class     Index      // @ref=TypeDef
	Interface CodedIndex // @code=TypeDefOrRef
}

type ManifestResource struct {
	Offset         uint32
	Flags          flags.ManifestResourceAttributes
	Name           String
	Implementation CodedIndex // @code=Implementation
}

type MemberRef struct {
	Class     CodedIndex // @code=MemberRefParent
	Name      String
	Signature []byte
}

type Metadata struct {
	Version string
	Tables  *Tables
	Strings StringHeap
	US      USHeap
	Blob    BlobHeap
	GUID    GUIDHeap
	// contains filtered or unexported fields
}

type MethodDef struct {
	RVA       uint32
	ImplFlags flags.MethodImplAttributes
	Flags     flags.MethodAttributes
	Name      String
	Signature SigMethodDefBlob
	ParamList Slice // @ref=Param
}

type MethodImpl struct {
	Class             Index      // @ref=TypeDef
	MethodBody        CodedIndex // @code=MethodDefOrRef
	MethodDeclaration CodedIndex // @code=MethodDefOrRef
}

type MethodSemantics struct {
	Semantics   flags.MethodSemanticsAttributes
	Method      Index      // @ref=MethodDef
	Association CodedIndex // @code=HasSemantics
}

type MethodSpec struct {
	Method        CodedIndex // @code=MethodDefOrRef
	Instantiation []byte
}

type Module struct {
	Generation uint16
	Name       String
	Mvid       [16]byte
	EncID      [16]byte
	EncBaseID  [16]byte
}

type ModuleRef struct {
	Name String
}

type NestedClass struct {
	NestedClass    Index // @ref=TypeDef
	EnclosingClass Index // @ref=TypeDef
}

type Param struct {
	Flags    flags.ParamAttributes
	Sequence uint16
	Name     String
}

type Property struct {
	Flags flags.PropertyAttributes
	Name  String
	Type  SigPropertyBlob
}

type PropertyMap struct {
	Parent       Index // @ref=TypeDef
	PropertyList Slice // @ref=Property
}

type Record[T any] interface {
	*T
	// contains filtered or unexported methods
}

type SigArray struct {
	Type        SigType
	Rank        uint32
	Sizes       []uint32
	LowerBounds []int32
}

type SigConstraint struct {
	Pinned bool
}

type SigCustomMod struct {
	Kind  SigCustomModKind
	Index CodedIndex
}

type SigCustomModKind uint8

type SigField struct {
	Type SigType
}

type SigFieldBlob []byte

type SigGenericInst struct {
	Class bool
	Index CodedIndex
	Type  []SigType
}

type SigLocalVar struct {
	Kind SigLocalVarKind
	Mod  []SigLocalVarMod // empty if Kind is TypedByRef
	Type SigType          // empty if Kind is TypedByRef
}

type SigLocalVarKind uint8

type SigLocalVarMod struct {
	Mod        *SigCustomMod
	Constraint SigConstraint
}

type SigLocalVars []SigLocalVar

type SigMethodDef struct {
	HasThis      bool
	ExplicitThis bool
	VarArgs      bool
	Generic      uint32
	RetType      SigRetType
	Param        []SigParam
}

type SigMethodDefBlob []byte

type SigMethodRef struct {
	SigMethodDef
	VariableParam []Param
}

type SigMethodSpec []SigType

type SigParam struct {
	Kind SigParamKind
	Type SigType // empty if Kind is TypedByRef
}

type SigParamKind uint8

type SigProperty struct {
	HasThis bool
	SigField
	Param []SigParam
}

type SigPropertyBlob []byte

type SigRetType struct {
	Kind SigRetTypeKind
	Type SigType // empty if Kind is TypedByRef or Void
}

type SigRetTypeKind uint8

type SigType struct {
	Kind  flags.ElementType
	Mod   []SigCustomMod
	Value any // optional
}

type SigTypeSpec struct {
	Kind  flags.ElementType
	Value any
}

type Slice struct {
	Start Index
	End   Index
}

type StandAloneSig struct {
	Signature []byte
}

type String struct {
	// Start is the offset in the #Strings heap where the string starts. This is the parameter that
	// was passed to StringHeap.String to create this String. The strings heap doesn't contain
	// duplicate strings, so this value can be used to uniquely identify strings that come from the
	// same heap.
	Start uint32
	// contains filtered or unexported fields
}

type StringHeap []byte

type Table[T any, TP Record[T]] struct {
	Len uint32
	// contains filtered or unexported fields
}

type Tables struct {
	Assembly               Table[Assembly, *Assembly]
	AssemblyRef            Table[AssemblyRef, *AssemblyRef]
	ClassLayout            Table[ClassLayout, *ClassLayout]
	Constant               Table[Constant, *Constant]
	CustomAttribute        Table[CustomAttribute, *CustomAttribute]
	DeclSecurity           Table[DeclSecurity, *DeclSecurity]
	EventMap               Table[EventMap, *EventMap]
	Event                  Table[Event, *Event]
	ExportedType           Table[ExportedType, *ExportedType]
	Field                  Table[Field, *Field]
	FieldLayout            Table[FieldLayout, *FieldLayout]
	FieldMarshal           Table[FieldMarshal, *FieldMarshal]
	FieldRVA               Table[FieldRVA, *FieldRVA]
	File                   Table[File, *File]
	GenericParam           Table[GenericParam, *GenericParam]
	GenericParamConstraint Table[GenericParamConstraint, *GenericParamConstraint]
	ImplMap                Table[ImplMap, *ImplMap]
	InterfaceImpl          Table[InterfaceImpl, *InterfaceImpl]
	ManifestResource       Table[ManifestResource, *ManifestResource]
	MemberRef              Table[MemberRef, *MemberRef]
	MethodDef              Table[MethodDef, *MethodDef]
	MethodImpl             Table[MethodImpl, *MethodImpl]
	MethodSemantics        Table[MethodSemantics, *MethodSemantics]
	MethodSpec             Table[MethodSpec, *MethodSpec]
	Module                 Table[Module, *Module]
	ModuleRef              Table[ModuleRef, *ModuleRef]
	NestedClass            Table[NestedClass, *NestedClass]
	Param                  Table[Param, *Param]
	Property               Table[Property, *Property]
	PropertyMap            Table[PropertyMap, *PropertyMap]
	StandAloneSig          Table[StandAloneSig, *StandAloneSig]
	TypeDef                Table[TypeDef, *TypeDef]
	TypeRef                Table[TypeRef, *TypeRef]
	TypeSpec               Table[TypeSpec, *TypeSpec]
}

type TypeDef struct {
	Flags      flags.TypeAttributes
	Name       String
	Namespace  String
	Extends    CodedIndex // @code=TypeDefOrRef
	FieldList  Slice      // @ref=Field
	MethodList Slice      // @ref=MethodDef
}

type TypeRef struct {
	ResolutionScope CodedIndex // @code=ResolutionScope
	Name            String
	Namespace       String
}

type TypeSpec struct {
	Signature []byte
}

type USHeap []byte