package flatbuf

Import Path
	github.com/apache/arrow-go/v18/arrow/internal/flatbuf (on go.dev)

Dependency Relation
	imports 2 packages, and imported by 3 packages

Involved Source Files

	    Binary.go
	    BinaryView.go
	    Block.go
	    BodyCompression.go
	    BodyCompressionMethod.go
	    Bool.go
	    Buffer.go
	    CompressionType.go
	    Date.go
	    DateUnit.go
	    Decimal.go
	    DictionaryBatch.go
	    DictionaryEncoding.go
	    DictionaryKind.go
	    Duration.go
	    Endianness.go
	    Feature.go
	    Field.go
	    FieldNode.go
	    FixedSizeBinary.go
	    FixedSizeList.go
	    FloatingPoint.go
	    Footer.go
	    Int.go
	    Interval.go
	    IntervalUnit.go
	    KeyValue.go
	    LargeBinary.go
	    LargeList.go
	    LargeListView.go
	    LargeUtf8.go
	    List.go
	    ListView.go
	    Map.go
	    Message.go
	    MessageHeader.go
	    MetadataVersion.go
	    Null.go
	    Precision.go
	    RecordBatch.go
	    RunEndEncoded.go
	    RunLengthEncoded.go
	    Schema.go
	    SparseMatrixCompressedAxis.go
	    SparseMatrixIndexCSR.go
	    SparseMatrixIndexCSX.go
	    SparseTensor.go
	    SparseTensorIndex.go
	    SparseTensorIndexCOO.go
	    SparseTensorIndexCSF.go
	    Struct_.go
	    Tensor.go
	    TensorDim.go
	    Time.go
	    TimeUnit.go
	    Timestamp.go
	    Type.go
	    Union.go
	    UnionMode.go
	    Utf8.go
	    Utf8View.go
Package-Level Type Names (total 61)

	/* sort by: alphabet | popularity */
	 type Binary (struct)
		/ Opaque binary data

		Methods (total 2)
			(*Binary) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Binary) Table() flatbuffers.Table
		Implements (at least one exported)
			*Binary : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsBinary(buf []byte, offset flatbuffers.UOffsetT) *Binary

	 type BinaryView (struct)
		/ Logically the same as Binary, but the internal representation uses a view
		/ struct that contains the string length and either the string's entire data
		/ inline (for small strings) or an inlined prefix, an index of another buffer,
		/ and an offset pointing to a slice in that buffer (for non-small strings).
		/
		/ Since it uses a variable number of data buffers, each Field with this type
		/ must have a corresponding entry in `variadicBufferCounts`.

		Methods (total 2)
			(*BinaryView) Init(buf []byte, i flatbuffers.UOffsetT)
			(*BinaryView) Table() flatbuffers.Table
		Implements (at least one exported)
			*BinaryView : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsBinaryView(buf []byte, offset flatbuffers.UOffsetT) *BinaryView

	 type Block (struct)

		Methods (total 8)
			(*Block) BodyLength() int64
				/ Length of the data (this is aligned so there can be a gap between this and
				/ the metadata).

			(*Block) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Block) MetaDataLength() int32
				/ Length of the metadata

			(*Block) MutateBodyLength(n int64) bool
				/ Length of the data (this is aligned so there can be a gap between this and
				/ the metadata).

			(*Block) MutateMetaDataLength(n int32) bool
				/ Length of the metadata

			(*Block) MutateOffset(n int64) bool
				/ Index to the start of the RecordBlock (note this is past the Message header)

			(*Block) Offset() int64
				/ Index to the start of the RecordBlock (note this is past the Message header)

			(*Block) Table() flatbuffers.Table
		Implements (at least one exported)
			*Block : github.com/google/flatbuffers/go.FlatBuffer
		As Inputs Of (at least 2)
			func (*Footer).Dictionaries(obj *Block, j int) bool
			func (*Footer).RecordBatches(obj *Block, j int) bool

	 type BodyCompression (struct)
		/ Optional compression for the memory buffers constituting IPC message
		/ bodies. Intended for use with RecordBatch but could be used for other
		/ message types

		Methods (total 6)
			(*BodyCompression) Codec() CompressionType
				/ Compressor library.
				/ For LZ4_FRAME, each compressed buffer must consist of a single frame.

			(*BodyCompression) Init(buf []byte, i flatbuffers.UOffsetT)
			(*BodyCompression) Method() BodyCompressionMethod
				/ Indicates the way the record batch body was compressed

			(*BodyCompression) MutateCodec(n CompressionType) bool
				/ Compressor library.
				/ For LZ4_FRAME, each compressed buffer must consist of a single frame.

			(*BodyCompression) MutateMethod(n BodyCompressionMethod) bool
				/ Indicates the way the record batch body was compressed

			(*BodyCompression) Table() flatbuffers.Table
		Implements (at least one exported)
			*BodyCompression : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least 2)
			func GetRootAsBodyCompression(buf []byte, offset flatbuffers.UOffsetT) *BodyCompression
			func (*RecordBatch).Compression(obj *BodyCompression) *BodyCompression
		As Inputs Of (at least one exported)
			func (*RecordBatch).Compression(obj *BodyCompression) *BodyCompression

	 type BodyCompressionMethod int8 (basic type)
		/ Provided for forward compatibility in case we need to support different
		/ strategies for compressing the IPC message body (like whole-body
		/ compression rather than buffer-level) in the future

		Methods (only one)
			( BodyCompressionMethod) String() string
		Implements (at least 2)
			 BodyCompressionMethod : expvar.Var
			 BodyCompressionMethod : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*BodyCompression).Method() BodyCompressionMethod
		As Inputs Of (at least 2)
			func BodyCompressionAddMethod(builder *flatbuffers.Builder, method BodyCompressionMethod)
			func (*BodyCompression).MutateMethod(n BodyCompressionMethod) bool
		As Types Of (only one)
			const BodyCompressionMethodBUFFER

	 type Bool (struct)

		Methods (total 2)
			(*Bool) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Bool) Table() flatbuffers.Table
		Implements (at least one exported)
			*Bool : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsBool(buf []byte, offset flatbuffers.UOffsetT) *Bool

	 type Buffer (struct)
		/ ----------------------------------------------------------------------
		/ A Buffer represents a single contiguous memory segment

		Methods (total 6)
			(*Buffer) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Buffer) Length() int64
				/ The absolute length (in bytes) of the memory buffer. The memory is found
				/ from offset (inclusive) to offset + length (non-inclusive). When building
				/ messages using the encapsulated IPC message, padding bytes may be written
				/ after a buffer, but such padding bytes do not need to be accounted for in
				/ the size here.

			(*Buffer) MutateLength(n int64) bool
				/ The absolute length (in bytes) of the memory buffer. The memory is found
				/ from offset (inclusive) to offset + length (non-inclusive). When building
				/ messages using the encapsulated IPC message, padding bytes may be written
				/ after a buffer, but such padding bytes do not need to be accounted for in
				/ the size here.

			(*Buffer) MutateOffset(n int64) bool
				/ The relative offset into the shared memory page where the bytes for this
				/ buffer starts

			(*Buffer) Offset() int64
				/ The relative offset into the shared memory page where the bytes for this
				/ buffer starts

			(*Buffer) Table() flatbuffers.Table
		Implements (at least one exported)
			*Buffer : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least 7)
			func (*SparseMatrixIndexCSR).IndicesBuffer(obj *Buffer) *Buffer
			func (*SparseMatrixIndexCSR).IndptrBuffer(obj *Buffer) *Buffer
			func (*SparseMatrixIndexCSX).IndicesBuffer(obj *Buffer) *Buffer
			func (*SparseMatrixIndexCSX).IndptrBuffer(obj *Buffer) *Buffer
			func (*SparseTensor).Data(obj *Buffer) *Buffer
			func (*SparseTensorIndexCOO).IndicesBuffer(obj *Buffer) *Buffer
			func (*Tensor).Data(obj *Buffer) *Buffer
		As Inputs Of (at least 10)
			func (*RecordBatch).Buffers(obj *Buffer, j int) bool
			func (*SparseMatrixIndexCSR).IndicesBuffer(obj *Buffer) *Buffer
			func (*SparseMatrixIndexCSR).IndptrBuffer(obj *Buffer) *Buffer
			func (*SparseMatrixIndexCSX).IndicesBuffer(obj *Buffer) *Buffer
			func (*SparseMatrixIndexCSX).IndptrBuffer(obj *Buffer) *Buffer
			func (*SparseTensor).Data(obj *Buffer) *Buffer
			func (*SparseTensorIndexCOO).IndicesBuffer(obj *Buffer) *Buffer
			func (*SparseTensorIndexCSF).IndicesBuffers(obj *Buffer, j int) bool
			func (*SparseTensorIndexCSF).IndptrBuffers(obj *Buffer, j int) bool
			func (*Tensor).Data(obj *Buffer) *Buffer

	 type CompressionType int8 (basic type)

		Methods (only one)
			( CompressionType) String() string
		Implements (at least 2)
			 CompressionType : expvar.Var
			 CompressionType : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*BodyCompression).Codec() CompressionType
		As Inputs Of (at least 2)
			func BodyCompressionAddCodec(builder *flatbuffers.Builder, codec CompressionType)
			func (*BodyCompression).MutateCodec(n CompressionType) bool
		As Types Of (total 2)
			const CompressionTypeLZ4_FRAME
			const CompressionTypeZSTD

	 type Date (struct)
		/ Date is either a 32-bit or 64-bit signed integer type representing an
		/ elapsed time since UNIX epoch (1970-01-01), stored in either of two units:
		/
		/ * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no
		/   leap seconds), where the values are evenly divisible by 86400000
		/ * Days (32 bits) since the UNIX epoch

		Methods (total 4)
			(*Date) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Date) MutateUnit(n DateUnit) bool
			(*Date) Table() flatbuffers.Table
			(*Date) Unit() DateUnit
		Implements (at least one exported)
			*Date : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsDate(buf []byte, offset flatbuffers.UOffsetT) *Date

	 type DateUnit int16 (basic type)

		Methods (only one)
			( DateUnit) String() string
		Implements (at least 2)
			 DateUnit : expvar.Var
			 DateUnit : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*Date).Unit() DateUnit
		As Inputs Of (at least 2)
			func DateAddUnit(builder *flatbuffers.Builder, unit DateUnit)
			func (*Date).MutateUnit(n DateUnit) bool
		As Types Of (total 2)
			const DateUnitDAY
			const DateUnitMILLISECOND

	 type Decimal (struct)
		/ Exact decimal value represented as an integer value in two's
		/ complement. Currently 32-bit (4-byte), 64-bit (8-byte),
		/ 128-bit (16-byte) and 256-bit (32-byte) integers are used.
		/ The representation uses the endianness indicated in the Schema.

		Methods (total 8)
			(*Decimal) BitWidth() int32
				/ Number of bits per value. The accepted widths are 32, 64, 128 and 256.
				/ We use bitWidth for consistency with Int::bitWidth.

			(*Decimal) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Decimal) MutateBitWidth(n int32) bool
				/ Number of bits per value. The accepted widths are 32, 64, 128 and 256.
				/ We use bitWidth for consistency with Int::bitWidth.

			(*Decimal) MutatePrecision(n int32) bool
				/ Total number of decimal digits

			(*Decimal) MutateScale(n int32) bool
				/ Number of digits after the decimal point "."

			(*Decimal) Precision() int32
				/ Total number of decimal digits

			(*Decimal) Scale() int32
				/ Number of digits after the decimal point "."

			(*Decimal) Table() flatbuffers.Table
		Implements (at least one exported)
			*Decimal : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsDecimal(buf []byte, offset flatbuffers.UOffsetT) *Decimal

	 type DictionaryBatch (struct)
		/ For sending dictionary encoding information. Any Field can be
		/ dictionary-encoded, but in this case none of its children may be
		/ dictionary-encoded.
		/ There is one vector / column per dictionary, but that vector / column
		/ may be spread across multiple dictionary batches by using the isDelta
		/ flag

		Methods (total 7)
			(*DictionaryBatch) Data(obj *RecordBatch) *RecordBatch
			(*DictionaryBatch) Id() int64
			(*DictionaryBatch) Init(buf []byte, i flatbuffers.UOffsetT)
			(*DictionaryBatch) IsDelta() bool
				/ If isDelta is true the values in the dictionary are to be appended to a
				/ dictionary with the indicated id. If isDelta is false this dictionary
				/ should replace the existing dictionary.

			(*DictionaryBatch) MutateId(n int64) bool
			(*DictionaryBatch) MutateIsDelta(n bool) bool
				/ If isDelta is true the values in the dictionary are to be appended to a
				/ dictionary with the indicated id. If isDelta is false this dictionary
				/ should replace the existing dictionary.

			(*DictionaryBatch) Table() flatbuffers.Table
		Implements (at least one exported)
			*DictionaryBatch : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsDictionaryBatch(buf []byte, offset flatbuffers.UOffsetT) *DictionaryBatch

	 type DictionaryEncoding (struct)

		Methods (total 9)
			(*DictionaryEncoding) DictionaryKind() DictionaryKind
			(*DictionaryEncoding) Id() int64
				/ The known dictionary id in the application where this data is used. In
				/ the file or streaming formats, the dictionary ids are found in the
				/ DictionaryBatch messages

			(*DictionaryEncoding) IndexType(obj *Int) *Int
				/ The dictionary indices are constrained to be non-negative integers. If
				/ this field is null, the indices must be signed int32. To maximize
				/ cross-language compatibility and performance, implementations are
				/ recommended to prefer signed integer types over unsigned integer types
				/ and to avoid uint64 indices unless they are required by an application.

			(*DictionaryEncoding) Init(buf []byte, i flatbuffers.UOffsetT)
			(*DictionaryEncoding) IsOrdered() bool
				/ The dictionary indices are constrained to be non-negative integers. If
				/ this field is null, the indices must be signed int32. To maximize
				/ cross-language compatibility and performance, implementations are
				/ recommended to prefer signed integer types over unsigned integer types
				/ and to avoid uint64 indices unless they are required by an application.
				/ By default, dictionaries are not ordered, or the order does not have
				/ semantic meaning. In some statistical, applications, dictionary-encoding
				/ is used to represent ordered categorical data, and we provide a way to
				/ preserve that metadata here

			(*DictionaryEncoding) MutateDictionaryKind(n DictionaryKind) bool
			(*DictionaryEncoding) MutateId(n int64) bool
				/ The known dictionary id in the application where this data is used. In
				/ the file or streaming formats, the dictionary ids are found in the
				/ DictionaryBatch messages

			(*DictionaryEncoding) MutateIsOrdered(n bool) bool
				/ By default, dictionaries are not ordered, or the order does not have
				/ semantic meaning. In some statistical, applications, dictionary-encoding
				/ is used to represent ordered categorical data, and we provide a way to
				/ preserve that metadata here

			(*DictionaryEncoding) Table() flatbuffers.Table
		Implements (at least one exported)
			*DictionaryEncoding : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least 2)
			func GetRootAsDictionaryEncoding(buf []byte, offset flatbuffers.UOffsetT) *DictionaryEncoding
			func (*Field).Dictionary(obj *DictionaryEncoding) *DictionaryEncoding
		As Inputs Of (at least one exported)
			func (*Field).Dictionary(obj *DictionaryEncoding) *DictionaryEncoding

	 type DictionaryKind int16 (basic type)
		/ ----------------------------------------------------------------------
		/ Dictionary encoding metadata
		/ Maintained for forwards compatibility, in the future
		/ Dictionaries might be explicit maps between integers and values
		/ allowing for non-contiguous index values

		Methods (only one)
			( DictionaryKind) String() string
		Implements (at least 2)
			 DictionaryKind : expvar.Var
			 DictionaryKind : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*DictionaryEncoding).DictionaryKind() DictionaryKind
		As Inputs Of (at least 2)
			func DictionaryEncodingAddDictionaryKind(builder *flatbuffers.Builder, dictionaryKind DictionaryKind)
			func (*DictionaryEncoding).MutateDictionaryKind(n DictionaryKind) bool
		As Types Of (only one)
			const DictionaryKindDenseArray

	 type Duration (struct)

		Methods (total 4)
			(*Duration) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Duration) MutateUnit(n TimeUnit) bool
			(*Duration) Table() flatbuffers.Table
			(*Duration) Unit() TimeUnit
		Implements (at least one exported)
			*Duration : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsDuration(buf []byte, offset flatbuffers.UOffsetT) *Duration

	 type Endianness int16 (basic type)
		/ ----------------------------------------------------------------------
		/ Endianness of the platform producing the data

		Methods (only one)
			( Endianness) String() string
		Implements (at least 2)
			 Endianness : expvar.Var
			 Endianness : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*Schema).Endianness() Endianness
		As Inputs Of (at least 2)
			func SchemaAddEndianness(builder *flatbuffers.Builder, endianness Endianness)
			func (*Schema).MutateEndianness(n Endianness) bool
		As Types Of (total 2)
			const EndiannessBig
			const EndiannessLittle

	 type Feature int64 (basic type)
		/ Represents Arrow Features that might not have full support
		/ within implementations. This is intended to be used in
		/ two scenarios:
		/  1.  A mechanism for readers of Arrow Streams
		/      and files to understand that the stream or file makes
		/      use of a feature that isn't supported or unknown to
		/      the implementation (and therefore can meet the Arrow
		/      forward compatibility guarantees).
		/  2.  A means of negotiating between a client and server
		/      what features a stream is allowed to use. The enums
		/      values here are intented to represent higher level
		/      features, additional details maybe negotiated
		/      with key-value pairs specific to the protocol.
		/
		/ Enums added to this list should be assigned power-of-two values
		/ to facilitate exchanging and comparing bitmaps for supported
		/ features.

		Methods (only one)
			( Feature) String() string
		Implements (at least 2)
			 Feature : expvar.Var
			 Feature : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*Schema).Features(j int) Feature
		As Inputs Of (at least one exported)
			func (*Schema).MutateFeatures(j int, n Feature) bool
		As Types Of (total 3)
			const FeatureCOMPRESSED_BODY
			const FeatureDICTIONARY_REPLACEMENT
			const FeatureUNUSED

	 type Field (struct)
		/ ----------------------------------------------------------------------
		/ A field represents a named column in a record / row batch or child of a
		/ nested type.

		Methods (total 13)
			(*Field) Children(obj *Field, j int) bool
				/ Present only if the field is dictionary encoded.
				/ children apply only to nested data types like Struct, List and Union. For
				/ primitive types children will have length 0.

			(*Field) ChildrenLength() int
			(*Field) CustomMetadata(obj *KeyValue, j int) bool
				/ children apply only to nested data types like Struct, List and Union. For
				/ primitive types children will have length 0.
				/ User-defined metadata

			(*Field) CustomMetadataLength() int
			(*Field) Dictionary(obj *DictionaryEncoding) *DictionaryEncoding
				/ This is the type of the decoded value if the field is dictionary encoded.
				/ Present only if the field is dictionary encoded.

			(*Field) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Field) MutateNullable(n bool) bool
				/ Whether or not this field can contain nulls. Should be true in general.

			(*Field) MutateTypeType(n Type) bool
			(*Field) Name() []byte
				/ Name is not required, in i.e. a List

			(*Field) Nullable() bool
				/ Name is not required, in i.e. a List
				/ Whether or not this field can contain nulls. Should be true in general.

			(*Field) Table() flatbuffers.Table
			(*Field) Type(obj *flatbuffers.Table) bool
				/ This is the type of the decoded value if the field is dictionary encoded.

			(*Field) TypeType() Type
		Implements (at least one exported)
			*Field : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsField(buf []byte, offset flatbuffers.UOffsetT) *Field
		As Inputs Of (at least 2)
			func (*Field).Children(obj *Field, j int) bool
			func (*Schema).Fields(obj *Field, j int) bool

	 type FieldNode (struct)
		/ ----------------------------------------------------------------------
		/ Data structures for describing a table row batch (a collection of
		/ equal-length Arrow arrays)
		/ Metadata about a field at some level of a nested type tree (but not
		/ its children).
		/
		/ For example, a List<Int16> with values `[[1, 2, 3], null, [4], [5, 6], null]`
		/ would have {length: 5, null_count: 2} for its List node, and {length: 6,
		/ null_count: 0} for its Int16 node, as separate FieldNode structs

		Methods (total 6)
			(*FieldNode) Init(buf []byte, i flatbuffers.UOffsetT)
			(*FieldNode) Length() int64
				/ The number of value slots in the Arrow array at this level of a nested
				/ tree

			(*FieldNode) MutateLength(n int64) bool
				/ The number of value slots in the Arrow array at this level of a nested
				/ tree

			(*FieldNode) MutateNullCount(n int64) bool
				/ The number of observed nulls. Fields with null_count == 0 may choose not
				/ to write their physical validity bitmap out as a materialized buffer,
				/ instead setting the length of the bitmap buffer to 0.

			(*FieldNode) NullCount() int64
				/ The number of observed nulls. Fields with null_count == 0 may choose not
				/ to write their physical validity bitmap out as a materialized buffer,
				/ instead setting the length of the bitmap buffer to 0.

			(*FieldNode) Table() flatbuffers.Table
		Implements (at least one exported)
			*FieldNode : github.com/google/flatbuffers/go.FlatBuffer
		As Inputs Of (at least one exported)
			func (*RecordBatch).Nodes(obj *FieldNode, j int) bool

	 type FixedSizeBinary (struct)

		Methods (total 4)
			(*FixedSizeBinary) ByteWidth() int32
				/ Number of bytes per value

			(*FixedSizeBinary) Init(buf []byte, i flatbuffers.UOffsetT)
			(*FixedSizeBinary) MutateByteWidth(n int32) bool
				/ Number of bytes per value

			(*FixedSizeBinary) Table() flatbuffers.Table
		Implements (at least one exported)
			*FixedSizeBinary : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsFixedSizeBinary(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeBinary

	 type FixedSizeList (struct)

		Methods (total 4)
			(*FixedSizeList) Init(buf []byte, i flatbuffers.UOffsetT)
			(*FixedSizeList) ListSize() int32
				/ Number of list items per value

			(*FixedSizeList) MutateListSize(n int32) bool
				/ Number of list items per value

			(*FixedSizeList) Table() flatbuffers.Table
		Implements (at least one exported)
			*FixedSizeList : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsFixedSizeList(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeList

	 type FloatingPoint (struct)

		Methods (total 4)
			(*FloatingPoint) Init(buf []byte, i flatbuffers.UOffsetT)
			(*FloatingPoint) MutatePrecision(n Precision) bool
			(*FloatingPoint) Precision() Precision
			(*FloatingPoint) Table() flatbuffers.Table
		Implements (at least one exported)
			*FloatingPoint : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsFloatingPoint(buf []byte, offset flatbuffers.UOffsetT) *FloatingPoint

	 type Footer (struct)
		/ ----------------------------------------------------------------------
		/ Arrow File metadata
		/

		Methods (total 11)
			(*Footer) CustomMetadata(obj *KeyValue, j int) bool
				/ User-defined metadata

			(*Footer) CustomMetadataLength() int
			(*Footer) Dictionaries(obj *Block, j int) bool
			(*Footer) DictionariesLength() int
			(*Footer) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Footer) MutateVersion(n MetadataVersion) bool
			(*Footer) RecordBatches(obj *Block, j int) bool
			(*Footer) RecordBatchesLength() int
			(*Footer) Schema(obj *Schema) *Schema
			(*Footer) Table() flatbuffers.Table
			(*Footer) Version() MetadataVersion
		Implements (at least one exported)
			*Footer : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsFooter(buf []byte, offset flatbuffers.UOffsetT) *Footer

	 type Int (struct)

		Methods (total 6)
			(*Int) BitWidth() int32
			(*Int) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Int) IsSigned() bool
			(*Int) MutateBitWidth(n int32) bool
			(*Int) MutateIsSigned(n bool) bool
			(*Int) Table() flatbuffers.Table
		Implements (at least one exported)
			*Int : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least 9)
			func GetRootAsInt(buf []byte, offset flatbuffers.UOffsetT) *Int
			func (*DictionaryEncoding).IndexType(obj *Int) *Int
			func (*SparseMatrixIndexCSR).IndicesType(obj *Int) *Int
			func (*SparseMatrixIndexCSR).IndptrType(obj *Int) *Int
			func (*SparseMatrixIndexCSX).IndicesType(obj *Int) *Int
			func (*SparseMatrixIndexCSX).IndptrType(obj *Int) *Int
			func (*SparseTensorIndexCOO).IndicesType(obj *Int) *Int
			func (*SparseTensorIndexCSF).IndicesType(obj *Int) *Int
			func (*SparseTensorIndexCSF).IndptrType(obj *Int) *Int
		As Inputs Of (at least 8)
			func (*DictionaryEncoding).IndexType(obj *Int) *Int
			func (*SparseMatrixIndexCSR).IndicesType(obj *Int) *Int
			func (*SparseMatrixIndexCSR).IndptrType(obj *Int) *Int
			func (*SparseMatrixIndexCSX).IndicesType(obj *Int) *Int
			func (*SparseMatrixIndexCSX).IndptrType(obj *Int) *Int
			func (*SparseTensorIndexCOO).IndicesType(obj *Int) *Int
			func (*SparseTensorIndexCSF).IndicesType(obj *Int) *Int
			func (*SparseTensorIndexCSF).IndptrType(obj *Int) *Int

	 type Interval (struct)

		Methods (total 4)
			(*Interval) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Interval) MutateUnit(n IntervalUnit) bool
			(*Interval) Table() flatbuffers.Table
			(*Interval) Unit() IntervalUnit
		Implements (at least one exported)
			*Interval : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsInterval(buf []byte, offset flatbuffers.UOffsetT) *Interval

	 type IntervalUnit int16 (basic type)

		Methods (only one)
			( IntervalUnit) String() string
		Implements (at least 2)
			 IntervalUnit : expvar.Var
			 IntervalUnit : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*Interval).Unit() IntervalUnit
		As Inputs Of (at least 2)
			func IntervalAddUnit(builder *flatbuffers.Builder, unit IntervalUnit)
			func (*Interval).MutateUnit(n IntervalUnit) bool
		As Types Of (total 3)
			const IntervalUnitDAY_TIME
			const IntervalUnitMONTH_DAY_NANO
			const IntervalUnitYEAR_MONTH

	 type KeyValue (struct)
		/ ----------------------------------------------------------------------
		/ user defined key value pairs to add custom metadata to arrow
		/ key namespacing is the responsibility of the user

		Methods (total 4)
			(*KeyValue) Init(buf []byte, i flatbuffers.UOffsetT)
			(*KeyValue) Key() []byte
			(*KeyValue) Table() flatbuffers.Table
			(*KeyValue) Value() []byte
		Implements (at least one exported)
			*KeyValue : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsKeyValue(buf []byte, offset flatbuffers.UOffsetT) *KeyValue
		As Inputs Of (at least 4)
			func (*Field).CustomMetadata(obj *KeyValue, j int) bool
			func (*Footer).CustomMetadata(obj *KeyValue, j int) bool
			func (*Message).CustomMetadata(obj *KeyValue, j int) bool
			func (*Schema).CustomMetadata(obj *KeyValue, j int) bool

	 type LargeBinary (struct)
		/ Same as Binary, but with 64-bit offsets, allowing to represent
		/ extremely large data values.

		Methods (total 2)
			(*LargeBinary) Init(buf []byte, i flatbuffers.UOffsetT)
			(*LargeBinary) Table() flatbuffers.Table
		Implements (at least one exported)
			*LargeBinary : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsLargeBinary(buf []byte, offset flatbuffers.UOffsetT) *LargeBinary

	 type LargeList (struct)
		/ Same as List, but with 64-bit offsets, allowing to represent
		/ extremely large data values.

		Methods (total 2)
			(*LargeList) Init(buf []byte, i flatbuffers.UOffsetT)
			(*LargeList) Table() flatbuffers.Table
		Implements (at least one exported)
			*LargeList : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsLargeList(buf []byte, offset flatbuffers.UOffsetT) *LargeList

	 type LargeListView (struct)
		/ Same as ListView, but with 64-bit offsets and sizes, allowing to represent
		/ extremely large data values.

		Methods (total 2)
			(*LargeListView) Init(buf []byte, i flatbuffers.UOffsetT)
			(*LargeListView) Table() flatbuffers.Table
		Implements (at least one exported)
			*LargeListView : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsLargeListView(buf []byte, offset flatbuffers.UOffsetT) *LargeListView

	 type LargeUtf8 (struct)
		/ Same as Utf8, but with 64-bit offsets, allowing to represent
		/ extremely large data values.

		Methods (total 2)
			(*LargeUtf8) Init(buf []byte, i flatbuffers.UOffsetT)
			(*LargeUtf8) Table() flatbuffers.Table
		Implements (at least one exported)
			*LargeUtf8 : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsLargeUtf8(buf []byte, offset flatbuffers.UOffsetT) *LargeUtf8

	 type List (struct)

		Methods (total 2)
			(*List) Init(buf []byte, i flatbuffers.UOffsetT)
			(*List) Table() flatbuffers.Table
		Implements (at least one exported)
			*List : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsList(buf []byte, offset flatbuffers.UOffsetT) *List

	 type ListView (struct)
		/ Represents the same logical types that List can, but contains offsets and
		/ sizes allowing for writes in any order and sharing of child values among
		/ list values.

		Methods (total 2)
			(*ListView) Init(buf []byte, i flatbuffers.UOffsetT)
			(*ListView) Table() flatbuffers.Table
		Implements (at least one exported)
			*ListView : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsListView(buf []byte, offset flatbuffers.UOffsetT) *ListView

	 type Map (struct)
		/ A Map is a logical nested type that is represented as
		/
		/ List<entries: Struct<key: K, value: V>>
		/
		/ In this layout, the keys and values are each respectively contiguous. We do
		/ not constrain the key and value types, so the application is responsible
		/ for ensuring that the keys are hashable and unique. Whether the keys are sorted
		/ may be set in the metadata for this field.
		/
		/ In a field with Map type, the field has a child Struct field, which then
		/ has two children: key type and the second the value type. The names of the
		/ child fields may be respectively "entries", "key", and "value", but this is
		/ not enforced.
		/
		/ Map
		/ ```text
		/   - child[0] entries: Struct
		/     - child[0] key: K
		/     - child[1] value: V
		/ ```
		/ Neither the "entries" field nor the "key" field may be nullable.
		/
		/ The metadata is structured so that Arrow systems without special handling
		/ for Map can make Map an alias for List. The "layout" attribute for the Map
		/ field must have the same contents as a List.

		Methods (total 4)
			(*Map) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Map) KeysSorted() bool
				/ Set to true if the keys within each value are sorted

			(*Map) MutateKeysSorted(n bool) bool
				/ Set to true if the keys within each value are sorted

			(*Map) Table() flatbuffers.Table
		Implements (at least one exported)
			*Map : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsMap(buf []byte, offset flatbuffers.UOffsetT) *Map

	 type Message (struct)

		Methods (total 11)
			(*Message) BodyLength() int64
			(*Message) CustomMetadata(obj *KeyValue, j int) bool
			(*Message) CustomMetadataLength() int
			(*Message) Header(obj *flatbuffers.Table) bool
			(*Message) HeaderType() MessageHeader
			(*Message) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Message) MutateBodyLength(n int64) bool
			(*Message) MutateHeaderType(n MessageHeader) bool
			(*Message) MutateVersion(n MetadataVersion) bool
			(*Message) Table() flatbuffers.Table
			(*Message) Version() MetadataVersion
		Implements (at least one exported)
			*Message : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsMessage(buf []byte, offset flatbuffers.UOffsetT) *Message

	 type MessageHeader byte (basic type)
		/ ----------------------------------------------------------------------
		/ The root Message type
		/ This union enables us to easily send different message types without
		/ redundant storage, and in the future we can easily add new message types.
		/
		/ Arrow implementations do not need to implement all of the message types,
		/ which may include experimental metadata types. For maximum compatibility,
		/ it is best to send data using RecordBatch

		Methods (only one)
			( MessageHeader) String() string
		Implements (at least 2)
			 MessageHeader : expvar.Var
			 MessageHeader : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*Message).HeaderType() MessageHeader
		As Inputs Of (at least 2)
			func MessageAddHeaderType(builder *flatbuffers.Builder, headerType MessageHeader)
			func (*Message).MutateHeaderType(n MessageHeader) bool
		As Types Of (total 6)
			const MessageHeaderDictionaryBatch
			const MessageHeaderNONE
			const MessageHeaderRecordBatch
			const MessageHeaderSchema
			const MessageHeaderSparseTensor
			const MessageHeaderTensor

	 type MetadataVersion int16 (basic type)

		Methods (only one)
			( MetadataVersion) String() string
		Implements (at least 2)
			 MetadataVersion : expvar.Var
			 MetadataVersion : fmt.Stringer
		As Outputs Of (at least 2)
			func (*Footer).Version() MetadataVersion
			func (*Message).Version() MetadataVersion
		As Inputs Of (at least 5)
			func FooterAddVersion(builder *flatbuffers.Builder, version MetadataVersion)
			func MessageAddVersion(builder *flatbuffers.Builder, version MetadataVersion)
			func (*Footer).MutateVersion(n MetadataVersion) bool
			func (*Message).MutateVersion(n MetadataVersion) bool
			func github.com/apache/arrow-go/v18/arrow/internal.HasValidityBitmap(id arrow.Type, version MetadataVersion) bool
		As Types Of (total 6)
			const MetadataVersionV1
			const MetadataVersionV2
			const MetadataVersionV3
			const MetadataVersionV4
			const MetadataVersionV5
			const github.com/apache/arrow-go/v18/arrow/internal.CurMetadataVersion

	 type Null (struct)
		/ These are stored in the flatbuffer in the Type union below

		Methods (total 2)
			(*Null) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Null) Table() flatbuffers.Table
		Implements (at least one exported)
			*Null : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsNull(buf []byte, offset flatbuffers.UOffsetT) *Null

	 type Precision int16 (basic type)

		Methods (only one)
			( Precision) String() string
		Implements (at least 2)
			 Precision : expvar.Var
			 Precision : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*FloatingPoint).Precision() Precision
		As Inputs Of (at least 2)
			func FloatingPointAddPrecision(builder *flatbuffers.Builder, precision Precision)
			func (*FloatingPoint).MutatePrecision(n Precision) bool
		As Types Of (total 3)
			const PrecisionDOUBLE
			const PrecisionHALF
			const PrecisionSINGLE

	 type RecordBatch (struct)
		/ A data header describing the shared memory layout of a "record" or "row"
		/ batch. Some systems call this a "row batch" internally and others a "record
		/ batch".

		Methods (total 12)
			(*RecordBatch) Buffers(obj *Buffer, j int) bool
				/ Nodes correspond to the pre-ordered flattened logical schema
				/ Buffers correspond to the pre-ordered flattened buffer tree
				/
				/ The number of buffers appended to this list depends on the schema. For
				/ example, most primitive arrays will have 2 buffers, 1 for the validity
				/ bitmap and 1 for the values. For struct arrays, there will only be a
				/ single buffer for the validity (nulls) bitmap

			(*RecordBatch) BuffersLength() int
			(*RecordBatch) Compression(obj *BodyCompression) *BodyCompression
				/ Buffers correspond to the pre-ordered flattened buffer tree
				/
				/ The number of buffers appended to this list depends on the schema. For
				/ example, most primitive arrays will have 2 buffers, 1 for the validity
				/ bitmap and 1 for the values. For struct arrays, there will only be a
				/ single buffer for the validity (nulls) bitmap
				/ Optional compression of the message body

			(*RecordBatch) Init(buf []byte, i flatbuffers.UOffsetT)
			(*RecordBatch) Length() int64
				/ number of records / rows. The arrays in the batch should all have this
				/ length

			(*RecordBatch) MutateLength(n int64) bool
				/ number of records / rows. The arrays in the batch should all have this
				/ length

			(*RecordBatch) MutateVariadicBufferCounts(j int, n int64) bool
				/ Some types such as Utf8View are represented using a variable number of buffers.
				/ For each such Field in the pre-ordered flattened logical schema, there will be
				/ an entry in variadicBufferCounts to indicate the number of number of variadic
				/ buffers which belong to that Field in the current RecordBatch.
				/
				/ For example, the schema
				/     col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
				/     col2: Utf8View
				/ contains two Fields with variadic buffers so variadicBufferCounts will have
				/ two entries, the first counting the variadic buffers of `col1.beta` and the
				/ second counting `col2`'s.
				/
				/ This field may be omitted if and only if the schema contains no Fields with
				/ a variable number of buffers, such as BinaryView and Utf8View.

			(*RecordBatch) Nodes(obj *FieldNode, j int) bool
				/ Nodes correspond to the pre-ordered flattened logical schema

			(*RecordBatch) NodesLength() int
			(*RecordBatch) Table() flatbuffers.Table
			(*RecordBatch) VariadicBufferCounts(j int) int64
				/ Optional compression of the message body
				/ Some types such as Utf8View are represented using a variable number of buffers.
				/ For each such Field in the pre-ordered flattened logical schema, there will be
				/ an entry in variadicBufferCounts to indicate the number of number of variadic
				/ buffers which belong to that Field in the current RecordBatch.
				/
				/ For example, the schema
				/     col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
				/     col2: Utf8View
				/ contains two Fields with variadic buffers so variadicBufferCounts will have
				/ two entries, the first counting the variadic buffers of `col1.beta` and the
				/ second counting `col2`'s.
				/
				/ This field may be omitted if and only if the schema contains no Fields with
				/ a variable number of buffers, such as BinaryView and Utf8View.

			(*RecordBatch) VariadicBufferCountsLength() int
		Implements (at least one exported)
			*RecordBatch : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least 2)
			func GetRootAsRecordBatch(buf []byte, offset flatbuffers.UOffsetT) *RecordBatch
			func (*DictionaryBatch).Data(obj *RecordBatch) *RecordBatch
		As Inputs Of (at least one exported)
			func (*DictionaryBatch).Data(obj *RecordBatch) *RecordBatch

	 type RunEndEncoded (struct)
		/ Contains two child arrays, run_ends and values.
		/ The run_ends child array must be a 16/32/64-bit integer array
		/ which encodes the indices at which the run with the value in
		/ each corresponding index in the values child array ends.
		/ Like list/struct types, the value array can be of any type.

		Methods (total 2)
			(*RunEndEncoded) Init(buf []byte, i flatbuffers.UOffsetT)
			(*RunEndEncoded) Table() flatbuffers.Table
		Implements (at least one exported)
			*RunEndEncoded : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsRunEndEncoded(buf []byte, offset flatbuffers.UOffsetT) *RunEndEncoded

	 type RunLengthEncoded (struct)

		Methods (total 2)
			(*RunLengthEncoded) Init(buf []byte, i flatbuffers.UOffsetT)
			(*RunLengthEncoded) Table() flatbuffers.Table
		Implements (at least one exported)
			*RunLengthEncoded : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsRunLengthEncoded(buf []byte, offset flatbuffers.UOffsetT) *RunLengthEncoded

	 type Schema (struct)
		/ ----------------------------------------------------------------------
		/ A Schema describes the columns in a row batch

		Methods (total 11)
			(*Schema) CustomMetadata(obj *KeyValue, j int) bool
			(*Schema) CustomMetadataLength() int
			(*Schema) Endianness() Endianness
				/ endianness of the buffer
				/ it is Little Endian by default
				/ if endianness doesn't match the underlying system then the vectors need to be converted

			(*Schema) Features(j int) Feature
				/ Features used in the stream/file.

			(*Schema) FeaturesLength() int
			(*Schema) Fields(obj *Field, j int) bool
			(*Schema) FieldsLength() int
			(*Schema) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Schema) MutateEndianness(n Endianness) bool
				/ endianness of the buffer
				/ it is Little Endian by default
				/ if endianness doesn't match the underlying system then the vectors need to be converted

			(*Schema) MutateFeatures(j int, n Feature) bool
				/ Features used in the stream/file.

			(*Schema) Table() flatbuffers.Table
		Implements (at least one exported)
			*Schema : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least 2)
			func GetRootAsSchema(buf []byte, offset flatbuffers.UOffsetT) *Schema
			func (*Footer).Schema(obj *Schema) *Schema
		As Inputs Of (at least one exported)
			func (*Footer).Schema(obj *Schema) *Schema

	 type SparseMatrixCompressedAxis int16 (basic type)

		Methods (only one)
			( SparseMatrixCompressedAxis) String() string
		Implements (at least 2)
			 SparseMatrixCompressedAxis : expvar.Var
			 SparseMatrixCompressedAxis : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*SparseMatrixIndexCSX).CompressedAxis() SparseMatrixCompressedAxis
		As Inputs Of (at least 2)
			func SparseMatrixIndexCSXAddCompressedAxis(builder *flatbuffers.Builder, compressedAxis SparseMatrixCompressedAxis)
			func (*SparseMatrixIndexCSX).MutateCompressedAxis(n SparseMatrixCompressedAxis) bool
		As Types Of (total 2)
			const SparseMatrixCompressedAxisColumn
			const SparseMatrixCompressedAxisRow

	 type SparseMatrixIndexCSR (struct)
		/ Compressed Sparse Row format, that is matrix-specific.

		Methods (total 6)
			(*SparseMatrixIndexCSR) IndicesBuffer(obj *Buffer) *Buffer
				/ The type of values in indicesBuffer
				/ indicesBuffer stores the location and size of the array that
				/ contains the column indices of the corresponding non-zero values.
				/ The type of index value is long.
				/
				/ For example, the indices of the above X is:
				/
				/   indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1].
				/
				/ Note that the indices are sorted in lexicographical order for each row.

			(*SparseMatrixIndexCSR) IndicesType(obj *Int) *Int
				/ indptrBuffer stores the location and size of indptr array that
				/ represents the range of the rows.
				/ The i-th row spans from indptr[i] to indptr[i+1] in the data.
				/ The length of this array is 1 + (the number of rows), and the type
				/ of index value is long.
				/
				/ For example, let X be the following 6x4 matrix:
				/
				/   X := [[0, 1, 2, 0],
				/         [0, 0, 3, 0],
				/         [0, 4, 0, 5],
				/         [0, 0, 0, 0],
				/         [6, 0, 7, 8],
				/         [0, 9, 0, 0]].
				/
				/ The array of non-zero values in X is:
				/
				/   values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
				/
				/ And the indptr of X is:
				/
				/   indptr(X) = [0, 2, 3, 5, 5, 8, 10].
				/ The type of values in indicesBuffer

			(*SparseMatrixIndexCSR) IndptrBuffer(obj *Buffer) *Buffer
				/ The type of values in indptrBuffer
				/ indptrBuffer stores the location and size of indptr array that
				/ represents the range of the rows.
				/ The i-th row spans from indptr[i] to indptr[i+1] in the data.
				/ The length of this array is 1 + (the number of rows), and the type
				/ of index value is long.
				/
				/ For example, let X be the following 6x4 matrix:
				/
				/   X := [[0, 1, 2, 0],
				/         [0, 0, 3, 0],
				/         [0, 4, 0, 5],
				/         [0, 0, 0, 0],
				/         [6, 0, 7, 8],
				/         [0, 9, 0, 0]].
				/
				/ The array of non-zero values in X is:
				/
				/   values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
				/
				/ And the indptr of X is:
				/
				/   indptr(X) = [0, 2, 3, 5, 5, 8, 10].

			(*SparseMatrixIndexCSR) IndptrType(obj *Int) *Int
				/ The type of values in indptrBuffer

			(*SparseMatrixIndexCSR) Init(buf []byte, i flatbuffers.UOffsetT)
			(*SparseMatrixIndexCSR) Table() flatbuffers.Table
		Implements (at least one exported)
			*SparseMatrixIndexCSR : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsSparseMatrixIndexCSR(buf []byte, offset flatbuffers.UOffsetT) *SparseMatrixIndexCSR

	 type SparseMatrixIndexCSX (struct)
		/ Compressed Sparse format, that is matrix-specific.

		Methods (total 8)
			(*SparseMatrixIndexCSX) CompressedAxis() SparseMatrixCompressedAxis
				/ Which axis, row or column, is compressed

			(*SparseMatrixIndexCSX) IndicesBuffer(obj *Buffer) *Buffer
				/ The type of values in indicesBuffer
				/ indicesBuffer stores the location and size of the array that
				/ contains the column indices of the corresponding non-zero values.
				/ The type of index value is long.
				/
				/ For example, the indices of the above X is:
				/ ```text
				/   indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1].
				/ ```
				/ Note that the indices are sorted in lexicographical order for each row.

			(*SparseMatrixIndexCSX) IndicesType(obj *Int) *Int
				/ indptrBuffer stores the location and size of indptr array that
				/ represents the range of the rows.
				/ The i-th row spans from `indptr[i]` to `indptr[i+1]` in the data.
				/ The length of this array is 1 + (the number of rows), and the type
				/ of index value is long.
				/
				/ For example, let X be the following 6x4 matrix:
				/ ```text
				/   X := [[0, 1, 2, 0],
				/         [0, 0, 3, 0],
				/         [0, 4, 0, 5],
				/         [0, 0, 0, 0],
				/         [6, 0, 7, 8],
				/         [0, 9, 0, 0]].
				/ ```
				/ The array of non-zero values in X is:
				/ ```text
				/   values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
				/ ```
				/ And the indptr of X is:
				/ ```text
				/   indptr(X) = [0, 2, 3, 5, 5, 8, 10].
				/ ```
				/ The type of values in indicesBuffer

			(*SparseMatrixIndexCSX) IndptrBuffer(obj *Buffer) *Buffer
				/ The type of values in indptrBuffer
				/ indptrBuffer stores the location and size of indptr array that
				/ represents the range of the rows.
				/ The i-th row spans from `indptr[i]` to `indptr[i+1]` in the data.
				/ The length of this array is 1 + (the number of rows), and the type
				/ of index value is long.
				/
				/ For example, let X be the following 6x4 matrix:
				/ ```text
				/   X := [[0, 1, 2, 0],
				/         [0, 0, 3, 0],
				/         [0, 4, 0, 5],
				/         [0, 0, 0, 0],
				/         [6, 0, 7, 8],
				/         [0, 9, 0, 0]].
				/ ```
				/ The array of non-zero values in X is:
				/ ```text
				/   values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
				/ ```
				/ And the indptr of X is:
				/ ```text
				/   indptr(X) = [0, 2, 3, 5, 5, 8, 10].
				/ ```

			(*SparseMatrixIndexCSX) IndptrType(obj *Int) *Int
				/ The type of values in indptrBuffer

			(*SparseMatrixIndexCSX) Init(buf []byte, i flatbuffers.UOffsetT)
			(*SparseMatrixIndexCSX) MutateCompressedAxis(n SparseMatrixCompressedAxis) bool
				/ Which axis, row or column, is compressed

			(*SparseMatrixIndexCSX) Table() flatbuffers.Table
		Implements (at least one exported)
			*SparseMatrixIndexCSX : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsSparseMatrixIndexCSX(buf []byte, offset flatbuffers.UOffsetT) *SparseMatrixIndexCSX

	 type SparseTensor (struct)

		Methods (total 13)
			(*SparseTensor) Data(obj *Buffer) *Buffer
				/ Sparse tensor index
				/ The location and size of the tensor's data

			(*SparseTensor) Init(buf []byte, i flatbuffers.UOffsetT)
			(*SparseTensor) MutateNonZeroLength(n int64) bool
				/ The number of non-zero values in a sparse tensor.

			(*SparseTensor) MutateSparseIndexType(n SparseTensorIndex) bool
			(*SparseTensor) MutateTypeType(n Type) bool
			(*SparseTensor) NonZeroLength() int64
				/ The dimensions of the tensor, optionally named.
				/ The number of non-zero values in a sparse tensor.

			(*SparseTensor) Shape(obj *TensorDim, j int) bool
				/ The type of data contained in a value cell.
				/ Currently only fixed-width value types are supported,
				/ no strings or nested types.
				/ The dimensions of the tensor, optionally named.

			(*SparseTensor) ShapeLength() int
			(*SparseTensor) SparseIndex(obj *flatbuffers.Table) bool
				/ Sparse tensor index

			(*SparseTensor) SparseIndexType() SparseTensorIndex
			(*SparseTensor) Table() flatbuffers.Table
			(*SparseTensor) Type(obj *flatbuffers.Table) bool
				/ The type of data contained in a value cell.
				/ Currently only fixed-width value types are supported,
				/ no strings or nested types.

			(*SparseTensor) TypeType() Type
		Implements (at least one exported)
			*SparseTensor : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsSparseTensor(buf []byte, offset flatbuffers.UOffsetT) *SparseTensor

	 type SparseTensorIndex byte (basic type)

		Methods (only one)
			( SparseTensorIndex) String() string
		Implements (at least 2)
			 SparseTensorIndex : expvar.Var
			 SparseTensorIndex : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*SparseTensor).SparseIndexType() SparseTensorIndex
		As Inputs Of (at least 2)
			func SparseTensorAddSparseIndexType(builder *flatbuffers.Builder, sparseIndexType SparseTensorIndex)
			func (*SparseTensor).MutateSparseIndexType(n SparseTensorIndex) bool
		As Types Of (total 4)
			const SparseTensorIndexNONE
			const SparseTensorIndexSparseMatrixIndexCSX
			const SparseTensorIndexSparseTensorIndexCOO
			const SparseTensorIndexSparseTensorIndexCSF

	 type SparseTensorIndexCOO (struct)
		/ ----------------------------------------------------------------------
		/ EXPERIMENTAL: Data structures for sparse tensors
		/ Coordinate (COO) format of sparse tensor index.
		/
		/ COO's index list are represented as a NxM matrix,
		/ where N is the number of non-zero values,
		/ and M is the number of dimensions of a sparse tensor.
		/
		/ indicesBuffer stores the location and size of the data of this indices
		/ matrix.  The value type and the stride of the indices matrix is
		/ specified in indicesType and indicesStrides fields.
		/
		/ For example, let X be a 2x3x4x5 tensor, and it has the following
		/ 6 non-zero values:
		/ ```text
		/   X[0, 1, 2, 0] := 1
		/   X[1, 1, 2, 3] := 2
		/   X[0, 2, 1, 0] := 3
		/   X[0, 1, 3, 0] := 4
		/   X[0, 1, 2, 1] := 5
		/   X[1, 2, 0, 4] := 6
		/ ```
		/ In COO format, the index matrix of X is the following 4x6 matrix:
		/ ```text
		/   [[0, 0, 0, 0, 1, 1],
		/    [1, 1, 1, 2, 1, 2],
		/    [2, 2, 3, 1, 2, 0],
		/    [0, 1, 0, 0, 3, 4]]
		/ ```
		/ When isCanonical is true, the indices is sorted in lexicographical order
		/ (row-major order), and it does not have duplicated entries.  Otherwise,
		/ the indices may not be sorted, or may have duplicated entries.

		Methods (total 9)
			(*SparseTensorIndexCOO) IndicesBuffer(obj *Buffer) *Buffer
				/ The location and size of the indices matrix's data

			(*SparseTensorIndexCOO) IndicesStrides(j int) int64
				/ The type of values in indicesBuffer
				/ Non-negative byte offsets to advance one value cell along each dimension
				/ If omitted, default to row-major order (C-like).

			(*SparseTensorIndexCOO) IndicesStridesLength() int
			(*SparseTensorIndexCOO) IndicesType(obj *Int) *Int
				/ The type of values in indicesBuffer

			(*SparseTensorIndexCOO) Init(buf []byte, i flatbuffers.UOffsetT)
			(*SparseTensorIndexCOO) IsCanonical() bool
				/ The location and size of the indices matrix's data
				/ This flag is true if and only if the indices matrix is sorted in
				/ row-major order, and does not have duplicated entries.
				/ This sort order is the same as of Tensorflow's SparseTensor,
				/ but it is inverse order of SciPy's canonical coo_matrix
				/ (SciPy employs column-major order for its coo_matrix).

			(*SparseTensorIndexCOO) MutateIndicesStrides(j int, n int64) bool
				/ Non-negative byte offsets to advance one value cell along each dimension
				/ If omitted, default to row-major order (C-like).

			(*SparseTensorIndexCOO) MutateIsCanonical(n bool) bool
				/ This flag is true if and only if the indices matrix is sorted in
				/ row-major order, and does not have duplicated entries.
				/ This sort order is the same as of Tensorflow's SparseTensor,
				/ but it is inverse order of SciPy's canonical coo_matrix
				/ (SciPy employs column-major order for its coo_matrix).

			(*SparseTensorIndexCOO) Table() flatbuffers.Table
		Implements (at least one exported)
			*SparseTensorIndexCOO : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsSparseTensorIndexCOO(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCOO

	 type SparseTensorIndexCSF (struct)
		/ Compressed Sparse Fiber (CSF) sparse tensor index.

		Methods (total 11)
			(*SparseTensorIndexCSF) AxisOrder(j int) int32
				/ indicesBuffers stores values of nodes.
				/ Each tensor dimension corresponds to a buffer in indicesBuffers.
				/ For example, the indicesBuffers for the above X is:
				/ ```text
				/   indicesBuffer(X) = [
				/                        [0, 1],
				/                        [0, 1, 1],
				/                        [0, 0, 1, 1],
				/                        [1, 2, 0, 2, 0, 0, 1, 2]
				/                      ].
				/ ```
				/ axisOrder stores the sequence in which dimensions were traversed to
				/ produce the prefix tree.
				/ For example, the axisOrder for the above X is:
				/ ```text
				/   axisOrder(X) = [0, 1, 2, 3].
				/ ```

			(*SparseTensorIndexCSF) AxisOrderLength() int
			(*SparseTensorIndexCSF) IndicesBuffers(obj *Buffer, j int) bool
				/ The type of values in indicesBuffers
				/ indicesBuffers stores values of nodes.
				/ Each tensor dimension corresponds to a buffer in indicesBuffers.
				/ For example, the indicesBuffers for the above X is:
				/ ```text
				/   indicesBuffer(X) = [
				/                        [0, 1],
				/                        [0, 1, 1],
				/                        [0, 0, 1, 1],
				/                        [1, 2, 0, 2, 0, 0, 1, 2]
				/                      ].
				/ ```

			(*SparseTensorIndexCSF) IndicesBuffersLength() int
			(*SparseTensorIndexCSF) IndicesType(obj *Int) *Int
				/ indptrBuffers stores the sparsity structure.
				/ Each two consecutive dimensions in a tensor correspond to a buffer in
				/ indptrBuffers. A pair of consecutive values at `indptrBuffers[dim][i]`
				/ and `indptrBuffers[dim][i + 1]` signify a range of nodes in
				/ `indicesBuffers[dim + 1]` who are children of `indicesBuffers[dim][i]` node.
				/
				/ For example, the indptrBuffers for the above X is:
				/ ```text
				/   indptrBuffer(X) = [
				/                       [0, 2, 3],
				/                       [0, 1, 3, 4],
				/                       [0, 2, 4, 5, 8]
				/                     ].
				/ ```
				/ The type of values in indicesBuffers

			(*SparseTensorIndexCSF) IndptrBuffers(obj *Buffer, j int) bool
				/ CSF is a generalization of compressed sparse row (CSR) index.
				/ See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf)
				/
				/ CSF index recursively compresses each dimension of a tensor into a set
				/ of prefix trees. Each path from a root to leaf forms one tensor
				/ non-zero index. CSF is implemented with two arrays of buffers and one
				/ arrays of integers.
				/
				/ For example, let X be a 2x3x4x5 tensor and let it have the following
				/ 8 non-zero values:
				/ ```text
				/   X[0, 0, 0, 1] := 1
				/   X[0, 0, 0, 2] := 2
				/   X[0, 1, 0, 0] := 3
				/   X[0, 1, 0, 2] := 4
				/   X[0, 1, 1, 0] := 5
				/   X[1, 1, 1, 0] := 6
				/   X[1, 1, 1, 1] := 7
				/   X[1, 1, 1, 2] := 8
				/ ```
				/ As a prefix tree this would be represented as:
				/ ```text
				/         0          1
				/        / \         |
				/       0   1        1
				/      /   / \       |
				/     0   0   1      1
				/    /|  /|   |    /| |
				/   1 2 0 2   0   0 1 2
				/ ```
				/ The type of values in indptrBuffers
				/ indptrBuffers stores the sparsity structure.
				/ Each two consecutive dimensions in a tensor correspond to a buffer in
				/ indptrBuffers. A pair of consecutive values at `indptrBuffers[dim][i]`
				/ and `indptrBuffers[dim][i + 1]` signify a range of nodes in
				/ `indicesBuffers[dim + 1]` who are children of `indicesBuffers[dim][i]` node.
				/
				/ For example, the indptrBuffers for the above X is:
				/ ```text
				/   indptrBuffer(X) = [
				/                       [0, 2, 3],
				/                       [0, 1, 3, 4],
				/                       [0, 2, 4, 5, 8]
				/                     ].
				/ ```

			(*SparseTensorIndexCSF) IndptrBuffersLength() int
			(*SparseTensorIndexCSF) IndptrType(obj *Int) *Int
				/ CSF is a generalization of compressed sparse row (CSR) index.
				/ See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf)
				/
				/ CSF index recursively compresses each dimension of a tensor into a set
				/ of prefix trees. Each path from a root to leaf forms one tensor
				/ non-zero index. CSF is implemented with two arrays of buffers and one
				/ arrays of integers.
				/
				/ For example, let X be a 2x3x4x5 tensor and let it have the following
				/ 8 non-zero values:
				/ ```text
				/   X[0, 0, 0, 1] := 1
				/   X[0, 0, 0, 2] := 2
				/   X[0, 1, 0, 0] := 3
				/   X[0, 1, 0, 2] := 4
				/   X[0, 1, 1, 0] := 5
				/   X[1, 1, 1, 0] := 6
				/   X[1, 1, 1, 1] := 7
				/   X[1, 1, 1, 2] := 8
				/ ```
				/ As a prefix tree this would be represented as:
				/ ```text
				/         0          1
				/        / \         |
				/       0   1        1
				/      /   / \       |
				/     0   0   1      1
				/    /|  /|   |    /| |
				/   1 2 0 2   0   0 1 2
				/ ```
				/ The type of values in indptrBuffers

			(*SparseTensorIndexCSF) Init(buf []byte, i flatbuffers.UOffsetT)
			(*SparseTensorIndexCSF) MutateAxisOrder(j int, n int32) bool
				/ axisOrder stores the sequence in which dimensions were traversed to
				/ produce the prefix tree.
				/ For example, the axisOrder for the above X is:
				/ ```text
				/   axisOrder(X) = [0, 1, 2, 3].
				/ ```

			(*SparseTensorIndexCSF) Table() flatbuffers.Table
		Implements (at least one exported)
			*SparseTensorIndexCSF : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsSparseTensorIndexCSF(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCSF

	 type Struct_ (struct)
		/ A Struct_ in the flatbuffer metadata is the same as an Arrow Struct
		/ (according to the physical memory layout). We used Struct_ here as
		/ Struct is a reserved word in Flatbuffers

		Methods (total 2)
			(*Struct_) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Struct_) Table() flatbuffers.Table
		Implements (at least one exported)
			*Struct_ : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsStruct_(buf []byte, offset flatbuffers.UOffsetT) *Struct_

	 type Tensor (struct)

		Methods (total 11)
			(*Tensor) Data(obj *Buffer) *Buffer
				/ The location and size of the tensor's data

			(*Tensor) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Tensor) MutateStrides(j int, n int64) bool
				/ Non-negative byte offsets to advance one value cell along each dimension
				/ If omitted, default to row-major order (C-like).

			(*Tensor) MutateTypeType(n Type) bool
			(*Tensor) Shape(obj *TensorDim, j int) bool
				/ The type of data contained in a value cell. Currently only fixed-width
				/ value types are supported, no strings or nested types
				/ The dimensions of the tensor, optionally named

			(*Tensor) ShapeLength() int
			(*Tensor) Strides(j int) int64
				/ The dimensions of the tensor, optionally named
				/ Non-negative byte offsets to advance one value cell along each dimension
				/ If omitted, default to row-major order (C-like).

			(*Tensor) StridesLength() int
			(*Tensor) Table() flatbuffers.Table
			(*Tensor) Type(obj *flatbuffers.Table) bool
				/ The type of data contained in a value cell. Currently only fixed-width
				/ value types are supported, no strings or nested types

			(*Tensor) TypeType() Type
		Implements (at least one exported)
			*Tensor : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsTensor(buf []byte, offset flatbuffers.UOffsetT) *Tensor

	 type TensorDim (struct)
		/ ----------------------------------------------------------------------
		/ Data structures for dense tensors
		/ Shape data for a single axis in a tensor

		Methods (total 5)
			(*TensorDim) Init(buf []byte, i flatbuffers.UOffsetT)
			(*TensorDim) MutateSize(n int64) bool
				/ Length of dimension

			(*TensorDim) Name() []byte
				/ Name of the dimension, optional

			(*TensorDim) Size() int64
				/ Length of dimension

			(*TensorDim) Table() flatbuffers.Table
		Implements (at least one exported)
			*TensorDim : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsTensorDim(buf []byte, offset flatbuffers.UOffsetT) *TensorDim
		As Inputs Of (at least 2)
			func (*SparseTensor).Shape(obj *TensorDim, j int) bool
			func (*Tensor).Shape(obj *TensorDim, j int) bool

	 type Time (struct)
		/ Time is either a 32-bit or 64-bit signed integer type representing an
		/ elapsed time since midnight, stored in either of four units: seconds,
		/ milliseconds, microseconds or nanoseconds.
		/
		/ The integer `bitWidth` depends on the `unit` and must be one of the following:
		/ * SECOND and MILLISECOND: 32 bits
		/ * MICROSECOND and NANOSECOND: 64 bits
		/
		/ The allowed values are between 0 (inclusive) and 86400 (=24*60*60) seconds
		/ (exclusive), adjusted for the time unit (for example, up to 86400000
		/ exclusive for the MILLISECOND unit).
		/ This definition doesn't allow for leap seconds. Time values from
		/ measurements with leap seconds will need to be corrected when ingesting
		/ into Arrow (for example by replacing the value 86400 with 86399).

		Methods (total 6)
			(*Time) BitWidth() int32
			(*Time) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Time) MutateBitWidth(n int32) bool
			(*Time) MutateUnit(n TimeUnit) bool
			(*Time) Table() flatbuffers.Table
			(*Time) Unit() TimeUnit
		Implements (at least one exported)
			*Time : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsTime(buf []byte, offset flatbuffers.UOffsetT) *Time

	 type Timestamp (struct)
		/ Timestamp is a 64-bit signed integer representing an elapsed time since a
		/ fixed epoch, stored in either of four units: seconds, milliseconds,
		/ microseconds or nanoseconds, and is optionally annotated with a timezone.
		/
		/ Timestamp values do not include any leap seconds (in other words, all
		/ days are considered 86400 seconds long).
		/
		/ Timestamps with a non-empty timezone
		/ ------------------------------------
		/
		/ If a Timestamp column has a non-empty timezone value, its epoch is
		/ 1970-01-01 00:00:00 (January 1st 1970, midnight) in the *UTC* timezone
		/ (the Unix epoch), regardless of the Timestamp's own timezone.
		/
		/ Therefore, timestamp values with a non-empty timezone correspond to
		/ physical points in time together with some additional information about
		/ how the data was obtained and/or how to display it (the timezone).
		/
		/   For example, the timestamp value 0 with the timezone string "Europe/Paris"
		/   corresponds to "January 1st 1970, 00h00" in the UTC timezone, but the
		/   application may prefer to display it as "January 1st 1970, 01h00" in
		/   the Europe/Paris timezone (which is the same physical point in time).
		/
		/ One consequence is that timestamp values with a non-empty timezone
		/ can be compared and ordered directly, since they all share the same
		/ well-known point of reference (the Unix epoch).
		/
		/ Timestamps with an unset / empty timezone
		/ -----------------------------------------
		/
		/ If a Timestamp column has no timezone value, its epoch is
		/ 1970-01-01 00:00:00 (January 1st 1970, midnight) in an *unknown* timezone.
		/
		/ Therefore, timestamp values without a timezone cannot be meaningfully
		/ interpreted as physical points in time, but only as calendar / clock
		/ indications ("wall clock time") in an unspecified timezone.
		/
		/   For example, the timestamp value 0 with an empty timezone string
		/   corresponds to "January 1st 1970, 00h00" in an unknown timezone: there
		/   is not enough information to interpret it as a well-defined physical
		/   point in time.
		/
		/ One consequence is that timestamp values without a timezone cannot
		/ be reliably compared or ordered, since they may have different points of
		/ reference.  In particular, it is *not* possible to interpret an unset
		/ or empty timezone as the same as "UTC".
		/
		/ Conversion between timezones
		/ ----------------------------
		/
		/ If a Timestamp column has a non-empty timezone, changing the timezone
		/ to a different non-empty value is a metadata-only operation:
		/ the timestamp values need not change as their point of reference remains
		/ the same (the Unix epoch).
		/
		/ However, if a Timestamp column has no timezone value, changing it to a
		/ non-empty value requires to think about the desired semantics.
		/ One possibility is to assume that the original timestamp values are
		/ relative to the epoch of the timezone being set; timestamp values should
		/ then adjusted to the Unix epoch (for example, changing the timezone from
		/ empty to "Europe/Paris" would require converting the timestamp values
		/ from "Europe/Paris" to "UTC", which seems counter-intuitive but is
		/ nevertheless correct).
		/
		/ Guidelines for encoding data from external libraries
		/ ----------------------------------------------------
		/
		/ Date & time libraries often have multiple different data types for temporal
		/ data. In order to ease interoperability between different implementations the
		/ Arrow project has some recommendations for encoding these types into a Timestamp
		/ column.
		/
		/ An "instant" represents a physical point in time that has no relevant timezone
		/ (for example, astronomical data). To encode an instant, use a Timestamp with
		/ the timezone string set to "UTC", and make sure the Timestamp values
		/ are relative to the UTC epoch (January 1st 1970, midnight).
		/
		/ A "zoned date-time" represents a physical point in time annotated with an
		/ informative timezone (for example, the timezone in which the data was
		/ recorded).  To encode a zoned date-time, use a Timestamp with the timezone
		/ string set to the name of the timezone, and make sure the Timestamp values
		/ are relative to the UTC epoch (January 1st 1970, midnight).
		/
		/  (There is some ambiguity between an instant and a zoned date-time with the
		/   UTC timezone.  Both of these are stored the same in Arrow.  Typically,
		/   this distinction does not matter.  If it does, then an application should
		/   use custom metadata or an extension type to distinguish between the two cases.)
		/
		/ An "offset date-time" represents a physical point in time combined with an
		/ explicit offset from UTC.  To encode an offset date-time, use a Timestamp
		/ with the timezone string set to the numeric timezone offset string
		/ (e.g. "+03:00"), and make sure the Timestamp values are relative to
		/ the UTC epoch (January 1st 1970, midnight).
		/
		/ A "naive date-time" (also called "local date-time" in some libraries)
		/ represents a wall clock time combined with a calendar date, but with
		/ no indication of how to map this information to a physical point in time.
		/ Naive date-times must be handled with care because of this missing
		/ information, and also because daylight saving time (DST) may make
		/ some values ambiguous or nonexistent. A naive date-time may be
		/ stored as a struct with Date and Time fields. However, it may also be
		/ encoded into a Timestamp column with an empty timezone. The timestamp
		/ values should be computed "as if" the timezone of the date-time values
		/ was UTC; for example, the naive date-time "January 1st 1970, 00h00" would
		/ be encoded as timestamp value 0.

		Methods (total 5)
			(*Timestamp) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Timestamp) MutateUnit(n TimeUnit) bool
			(*Timestamp) Table() flatbuffers.Table
			(*Timestamp) Timezone() []byte
				/ The timezone is an optional string indicating the name of a timezone,
				/ one of:
				/
				/ * As used in the Olson timezone database (the "tz database" or
				/   "tzdata"), such as "America/New_York".
				/ * An absolute timezone offset of the form "+XX:XX" or "-XX:XX",
				/   such as "+07:30".
				/
				/ Whether a timezone string is present indicates different semantics about
				/ the data (see above).

			(*Timestamp) Unit() TimeUnit
		Implements (at least one exported)
			*Timestamp : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsTimestamp(buf []byte, offset flatbuffers.UOffsetT) *Timestamp

	 type TimeUnit int16 (basic type)

		Methods (only one)
			( TimeUnit) String() string
		Implements (at least 2)
			 TimeUnit : expvar.Var
			 TimeUnit : fmt.Stringer
		As Outputs Of (at least 3)
			func (*Duration).Unit() TimeUnit
			func (*Time).Unit() TimeUnit
			func (*Timestamp).Unit() TimeUnit
		As Inputs Of (at least 6)
			func DurationAddUnit(builder *flatbuffers.Builder, unit TimeUnit)
			func TimeAddUnit(builder *flatbuffers.Builder, unit TimeUnit)
			func TimestampAddUnit(builder *flatbuffers.Builder, unit TimeUnit)
			func (*Duration).MutateUnit(n TimeUnit) bool
			func (*Time).MutateUnit(n TimeUnit) bool
			func (*Timestamp).MutateUnit(n TimeUnit) bool
		As Types Of (total 4)
			const TimeUnitMICROSECOND
			const TimeUnitMILLISECOND
			const TimeUnitNANOSECOND
			const TimeUnitSECOND

	 type Type byte (basic type)
		/ ----------------------------------------------------------------------
		/ Top-level Type value, enabling extensible type-specific metadata. We can
		/ add new logical types to Type without breaking backwards compatibility

		Methods (only one)
			( Type) String() string
		Implements (at least 2)
			 Type : expvar.Var
			 Type : fmt.Stringer
		As Outputs Of (at least 3)
			func (*Field).TypeType() Type
			func (*SparseTensor).TypeType() Type
			func (*Tensor).TypeType() Type
		As Inputs Of (at least 6)
			func FieldAddTypeType(builder *flatbuffers.Builder, typeType Type)
			func SparseTensorAddTypeType(builder *flatbuffers.Builder, typeType Type)
			func TensorAddTypeType(builder *flatbuffers.Builder, typeType Type)
			func (*Field).MutateTypeType(n Type) bool
			func (*SparseTensor).MutateTypeType(n Type) bool
			func (*Tensor).MutateTypeType(n Type) bool
		As Types Of (total 27)
			const TypeBinary
			const TypeBinaryView
			const TypeBool
			const TypeDate
			const TypeDecimal
			const TypeDuration
			const TypeFixedSizeBinary
			const TypeFixedSizeList
			const TypeFloatingPoint
			const TypeInt
			const TypeInterval
			const TypeLargeBinary
			const TypeLargeList
			const TypeLargeListView
			const TypeLargeUtf8
			const TypeList
			const TypeListView
			const TypeMap
			const TypeNONE
			const TypeNull
			const TypeRunEndEncoded
			const TypeStruct_
			const TypeTime
			const TypeTimestamp
			const TypeUnion
			const TypeUtf8
			const TypeUtf8View

	 type Union (struct)
		/ A union is a complex type with children in Field
		/ By default ids in the type vector refer to the offsets in the children
		/ optionally typeIds provides an indirection between the child offset and the type id
		/ for each child `typeIds[offset]` is the id used in the type vector

		Methods (total 7)
			(*Union) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Union) Mode() UnionMode
			(*Union) MutateMode(n UnionMode) bool
			(*Union) MutateTypeIds(j int, n int32) bool
			(*Union) Table() flatbuffers.Table
			(*Union) TypeIds(j int) int32
			(*Union) TypeIdsLength() int
		Implements (at least one exported)
			*Union : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsUnion(buf []byte, offset flatbuffers.UOffsetT) *Union

	 type UnionMode int16 (basic type)

		Methods (only one)
			( UnionMode) String() string
		Implements (at least 2)
			 UnionMode : expvar.Var
			 UnionMode : fmt.Stringer
		As Outputs Of (at least one exported)
			func (*Union).Mode() UnionMode
		As Inputs Of (at least 2)
			func UnionAddMode(builder *flatbuffers.Builder, mode UnionMode)
			func (*Union).MutateMode(n UnionMode) bool
		As Types Of (total 2)
			const UnionModeDense
			const UnionModeSparse

	 type Utf8 (struct)
		/ Unicode with UTF-8 encoding

		Methods (total 2)
			(*Utf8) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Utf8) Table() flatbuffers.Table
		Implements (at least one exported)
			*Utf8 : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsUtf8(buf []byte, offset flatbuffers.UOffsetT) *Utf8

	 type Utf8View (struct)
		/ Logically the same as Utf8, but the internal representation uses a view
		/ struct that contains the string length and either the string's entire data
		/ inline (for small strings) or an inlined prefix, an index of another buffer,
		/ and an offset pointing to a slice in that buffer (for non-small strings).
		/
		/ Since it uses a variable number of data buffers, each Field with this type
		/ must have a corresponding entry in `variadicBufferCounts`.

		Methods (total 2)
			(*Utf8View) Init(buf []byte, i flatbuffers.UOffsetT)
			(*Utf8View) Table() flatbuffers.Table
		Implements (at least one exported)
			*Utf8View : github.com/google/flatbuffers/go.FlatBuffer
		As Outputs Of (at least one exported)
			func GetRootAsUtf8View(buf []byte, offset flatbuffers.UOffsetT) *Utf8View


Package-Level Functions (total 239)

	 func BinaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func BinaryStart(builder *flatbuffers.Builder)
	 func BinaryViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func BinaryViewStart(builder *flatbuffers.Builder)
	 func BodyCompressionAddCodec(builder *flatbuffers.Builder, codec CompressionType)
	 func BodyCompressionAddMethod(builder *flatbuffers.Builder, method BodyCompressionMethod)
	 func BodyCompressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func BodyCompressionStart(builder *flatbuffers.Builder)
	 func BoolEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func BoolStart(builder *flatbuffers.Builder)
	 func CreateBlock(builder *flatbuffers.Builder, offset int64, metaDataLength int32, bodyLength int64) flatbuffers.UOffsetT
	 func CreateBuffer(builder *flatbuffers.Builder, offset int64, length int64) flatbuffers.UOffsetT
	 func CreateFieldNode(builder *flatbuffers.Builder, length int64, nullCount int64) flatbuffers.UOffsetT
	 func DateAddUnit(builder *flatbuffers.Builder, unit DateUnit)
	 func DateEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func DateStart(builder *flatbuffers.Builder)
	 func DecimalAddBitWidth(builder *flatbuffers.Builder, bitWidth int32)
	 func DecimalAddPrecision(builder *flatbuffers.Builder, precision int32)
	 func DecimalAddScale(builder *flatbuffers.Builder, scale int32)
	 func DecimalEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func DecimalStart(builder *flatbuffers.Builder)
	 func DictionaryBatchAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT)
	 func DictionaryBatchAddId(builder *flatbuffers.Builder, id int64)
	 func DictionaryBatchAddIsDelta(builder *flatbuffers.Builder, isDelta bool)
	 func DictionaryBatchEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func DictionaryBatchStart(builder *flatbuffers.Builder)
	 func DictionaryEncodingAddDictionaryKind(builder *flatbuffers.Builder, dictionaryKind DictionaryKind)
	 func DictionaryEncodingAddId(builder *flatbuffers.Builder, id int64)
	 func DictionaryEncodingAddIndexType(builder *flatbuffers.Builder, indexType flatbuffers.UOffsetT)
	 func DictionaryEncodingAddIsOrdered(builder *flatbuffers.Builder, isOrdered bool)
	 func DictionaryEncodingEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func DictionaryEncodingStart(builder *flatbuffers.Builder)
	 func DurationAddUnit(builder *flatbuffers.Builder, unit TimeUnit)
	 func DurationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func DurationStart(builder *flatbuffers.Builder)
	 func FieldAddChildren(builder *flatbuffers.Builder, children flatbuffers.UOffsetT)
	 func FieldAddCustomMetadata(builder *flatbuffers.Builder, customMetadata flatbuffers.UOffsetT)
	 func FieldAddDictionary(builder *flatbuffers.Builder, dictionary flatbuffers.UOffsetT)
	 func FieldAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT)
	 func FieldAddNullable(builder *flatbuffers.Builder, nullable bool)
	 func FieldAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT)
	 func FieldAddTypeType(builder *flatbuffers.Builder, typeType Type)
	 func FieldEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func FieldStart(builder *flatbuffers.Builder)
		/ User-defined metadata

	 func FieldStartChildrenVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func FieldStartCustomMetadataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func FixedSizeBinaryAddByteWidth(builder *flatbuffers.Builder, byteWidth int32)
	 func FixedSizeBinaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func FixedSizeBinaryStart(builder *flatbuffers.Builder)
	 func FixedSizeListAddListSize(builder *flatbuffers.Builder, listSize int32)
	 func FixedSizeListEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func FixedSizeListStart(builder *flatbuffers.Builder)
	 func FloatingPointAddPrecision(builder *flatbuffers.Builder, precision Precision)
	 func FloatingPointEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func FloatingPointStart(builder *flatbuffers.Builder)
	 func FooterAddCustomMetadata(builder *flatbuffers.Builder, customMetadata flatbuffers.UOffsetT)
	 func FooterAddDictionaries(builder *flatbuffers.Builder, dictionaries flatbuffers.UOffsetT)
	 func FooterAddRecordBatches(builder *flatbuffers.Builder, recordBatches flatbuffers.UOffsetT)
	 func FooterAddSchema(builder *flatbuffers.Builder, schema flatbuffers.UOffsetT)
	 func FooterAddVersion(builder *flatbuffers.Builder, version MetadataVersion)
	 func FooterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func FooterStart(builder *flatbuffers.Builder)
		/ User-defined metadata

	 func FooterStartCustomMetadataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func FooterStartDictionariesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func FooterStartRecordBatchesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func GetRootAsBinary(buf []byte, offset flatbuffers.UOffsetT) *Binary
	 func GetRootAsBinaryView(buf []byte, offset flatbuffers.UOffsetT) *BinaryView
	 func GetRootAsBodyCompression(buf []byte, offset flatbuffers.UOffsetT) *BodyCompression
	 func GetRootAsBool(buf []byte, offset flatbuffers.UOffsetT) *Bool
	 func GetRootAsDate(buf []byte, offset flatbuffers.UOffsetT) *Date
	 func GetRootAsDecimal(buf []byte, offset flatbuffers.UOffsetT) *Decimal
	 func GetRootAsDictionaryBatch(buf []byte, offset flatbuffers.UOffsetT) *DictionaryBatch
	 func GetRootAsDictionaryEncoding(buf []byte, offset flatbuffers.UOffsetT) *DictionaryEncoding
	 func GetRootAsDuration(buf []byte, offset flatbuffers.UOffsetT) *Duration
	 func GetRootAsField(buf []byte, offset flatbuffers.UOffsetT) *Field
	 func GetRootAsFixedSizeBinary(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeBinary
	 func GetRootAsFixedSizeList(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeList
	 func GetRootAsFloatingPoint(buf []byte, offset flatbuffers.UOffsetT) *FloatingPoint
	 func GetRootAsFooter(buf []byte, offset flatbuffers.UOffsetT) *Footer
	 func GetRootAsInt(buf []byte, offset flatbuffers.UOffsetT) *Int
	 func GetRootAsInterval(buf []byte, offset flatbuffers.UOffsetT) *Interval
	 func GetRootAsKeyValue(buf []byte, offset flatbuffers.UOffsetT) *KeyValue
	 func GetRootAsLargeBinary(buf []byte, offset flatbuffers.UOffsetT) *LargeBinary
	 func GetRootAsLargeList(buf []byte, offset flatbuffers.UOffsetT) *LargeList
	 func GetRootAsLargeListView(buf []byte, offset flatbuffers.UOffsetT) *LargeListView
	 func GetRootAsLargeUtf8(buf []byte, offset flatbuffers.UOffsetT) *LargeUtf8
	 func GetRootAsList(buf []byte, offset flatbuffers.UOffsetT) *List
	 func GetRootAsListView(buf []byte, offset flatbuffers.UOffsetT) *ListView
	 func GetRootAsMap(buf []byte, offset flatbuffers.UOffsetT) *Map
	 func GetRootAsMessage(buf []byte, offset flatbuffers.UOffsetT) *Message
	 func GetRootAsNull(buf []byte, offset flatbuffers.UOffsetT) *Null
	 func GetRootAsRecordBatch(buf []byte, offset flatbuffers.UOffsetT) *RecordBatch
	 func GetRootAsRunEndEncoded(buf []byte, offset flatbuffers.UOffsetT) *RunEndEncoded
	 func GetRootAsRunLengthEncoded(buf []byte, offset flatbuffers.UOffsetT) *RunLengthEncoded
	 func GetRootAsSchema(buf []byte, offset flatbuffers.UOffsetT) *Schema
	 func GetRootAsSparseMatrixIndexCSR(buf []byte, offset flatbuffers.UOffsetT) *SparseMatrixIndexCSR
	 func GetRootAsSparseMatrixIndexCSX(buf []byte, offset flatbuffers.UOffsetT) *SparseMatrixIndexCSX
	 func GetRootAsSparseTensor(buf []byte, offset flatbuffers.UOffsetT) *SparseTensor
	 func GetRootAsSparseTensorIndexCOO(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCOO
	 func GetRootAsSparseTensorIndexCSF(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCSF
	 func GetRootAsStruct_(buf []byte, offset flatbuffers.UOffsetT) *Struct_
	 func GetRootAsTensor(buf []byte, offset flatbuffers.UOffsetT) *Tensor
	 func GetRootAsTensorDim(buf []byte, offset flatbuffers.UOffsetT) *TensorDim
	 func GetRootAsTime(buf []byte, offset flatbuffers.UOffsetT) *Time
	 func GetRootAsTimestamp(buf []byte, offset flatbuffers.UOffsetT) *Timestamp
	 func GetRootAsUnion(buf []byte, offset flatbuffers.UOffsetT) *Union
	 func GetRootAsUtf8(buf []byte, offset flatbuffers.UOffsetT) *Utf8
	 func GetRootAsUtf8View(buf []byte, offset flatbuffers.UOffsetT) *Utf8View
	 func IntAddBitWidth(builder *flatbuffers.Builder, bitWidth int32)
	 func IntAddIsSigned(builder *flatbuffers.Builder, isSigned bool)
	 func IntEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func IntervalAddUnit(builder *flatbuffers.Builder, unit IntervalUnit)
	 func IntervalEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func IntervalStart(builder *flatbuffers.Builder)
	 func IntStart(builder *flatbuffers.Builder)
	 func KeyValueAddKey(builder *flatbuffers.Builder, key flatbuffers.UOffsetT)
	 func KeyValueAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT)
	 func KeyValueEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func KeyValueStart(builder *flatbuffers.Builder)
	 func LargeBinaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func LargeBinaryStart(builder *flatbuffers.Builder)
	 func LargeListEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func LargeListStart(builder *flatbuffers.Builder)
	 func LargeListViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func LargeListViewStart(builder *flatbuffers.Builder)
	 func LargeUtf8End(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func LargeUtf8Start(builder *flatbuffers.Builder)
	 func ListEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func ListStart(builder *flatbuffers.Builder)
	 func ListViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func ListViewStart(builder *flatbuffers.Builder)
	 func MapAddKeysSorted(builder *flatbuffers.Builder, keysSorted bool)
	 func MapEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func MapStart(builder *flatbuffers.Builder)
	 func MessageAddBodyLength(builder *flatbuffers.Builder, bodyLength int64)
	 func MessageAddCustomMetadata(builder *flatbuffers.Builder, customMetadata flatbuffers.UOffsetT)
	 func MessageAddHeader(builder *flatbuffers.Builder, header flatbuffers.UOffsetT)
	 func MessageAddHeaderType(builder *flatbuffers.Builder, headerType MessageHeader)
	 func MessageAddVersion(builder *flatbuffers.Builder, version MetadataVersion)
	 func MessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func MessageStart(builder *flatbuffers.Builder)
	 func MessageStartCustomMetadataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func NullEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func NullStart(builder *flatbuffers.Builder)
	 func RecordBatchAddBuffers(builder *flatbuffers.Builder, buffers flatbuffers.UOffsetT)
	 func RecordBatchAddCompression(builder *flatbuffers.Builder, compression flatbuffers.UOffsetT)
	 func RecordBatchAddLength(builder *flatbuffers.Builder, length int64)
	 func RecordBatchAddNodes(builder *flatbuffers.Builder, nodes flatbuffers.UOffsetT)
	 func RecordBatchAddVariadicBufferCounts(builder *flatbuffers.Builder, variadicBufferCounts flatbuffers.UOffsetT)
	 func RecordBatchEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func RecordBatchStart(builder *flatbuffers.Builder)
	 func RecordBatchStartBuffersVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func RecordBatchStartNodesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func RecordBatchStartVariadicBufferCountsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func RunEndEncodedEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func RunEndEncodedStart(builder *flatbuffers.Builder)
	 func RunLengthEncodedEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func RunLengthEncodedStart(builder *flatbuffers.Builder)
	 func SchemaAddCustomMetadata(builder *flatbuffers.Builder, customMetadata flatbuffers.UOffsetT)
	 func SchemaAddEndianness(builder *flatbuffers.Builder, endianness Endianness)
	 func SchemaAddFeatures(builder *flatbuffers.Builder, features flatbuffers.UOffsetT)
	 func SchemaAddFields(builder *flatbuffers.Builder, fields flatbuffers.UOffsetT)
	 func SchemaEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func SchemaStart(builder *flatbuffers.Builder)
	 func SchemaStartCustomMetadataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func SchemaStartFeaturesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func SchemaStartFieldsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func SparseMatrixIndexCSRAddIndicesBuffer(builder *flatbuffers.Builder, indicesBuffer flatbuffers.UOffsetT)
	 func SparseMatrixIndexCSRAddIndicesType(builder *flatbuffers.Builder, indicesType flatbuffers.UOffsetT)
	 func SparseMatrixIndexCSRAddIndptrBuffer(builder *flatbuffers.Builder, indptrBuffer flatbuffers.UOffsetT)
	 func SparseMatrixIndexCSRAddIndptrType(builder *flatbuffers.Builder, indptrType flatbuffers.UOffsetT)
	 func SparseMatrixIndexCSREnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func SparseMatrixIndexCSRStart(builder *flatbuffers.Builder)
		/ indicesBuffer stores the location and size of the array that
		/ contains the column indices of the corresponding non-zero values.
		/ The type of index value is long.
		/
		/ For example, the indices of the above X is:
		/
		/   indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1].
		/
		/ Note that the indices are sorted in lexicographical order for each row.

	 func SparseMatrixIndexCSXAddCompressedAxis(builder *flatbuffers.Builder, compressedAxis SparseMatrixCompressedAxis)
	 func SparseMatrixIndexCSXAddIndicesBuffer(builder *flatbuffers.Builder, indicesBuffer flatbuffers.UOffsetT)
	 func SparseMatrixIndexCSXAddIndicesType(builder *flatbuffers.Builder, indicesType flatbuffers.UOffsetT)
	 func SparseMatrixIndexCSXAddIndptrBuffer(builder *flatbuffers.Builder, indptrBuffer flatbuffers.UOffsetT)
	 func SparseMatrixIndexCSXAddIndptrType(builder *flatbuffers.Builder, indptrType flatbuffers.UOffsetT)
	 func SparseMatrixIndexCSXEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func SparseMatrixIndexCSXStart(builder *flatbuffers.Builder)
		/ indicesBuffer stores the location and size of the array that
		/ contains the column indices of the corresponding non-zero values.
		/ The type of index value is long.
		/
		/ For example, the indices of the above X is:
		/ ```text
		/   indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1].
		/ ```
		/ Note that the indices are sorted in lexicographical order for each row.

	 func SparseTensorAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT)
	 func SparseTensorAddNonZeroLength(builder *flatbuffers.Builder, nonZeroLength int64)
	 func SparseTensorAddShape(builder *flatbuffers.Builder, shape flatbuffers.UOffsetT)
	 func SparseTensorAddSparseIndex(builder *flatbuffers.Builder, sparseIndex flatbuffers.UOffsetT)
	 func SparseTensorAddSparseIndexType(builder *flatbuffers.Builder, sparseIndexType SparseTensorIndex)
	 func SparseTensorAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT)
	 func SparseTensorAddTypeType(builder *flatbuffers.Builder, typeType Type)
	 func SparseTensorEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func SparseTensorIndexCOOAddIndicesBuffer(builder *flatbuffers.Builder, indicesBuffer flatbuffers.UOffsetT)
	 func SparseTensorIndexCOOAddIndicesStrides(builder *flatbuffers.Builder, indicesStrides flatbuffers.UOffsetT)
	 func SparseTensorIndexCOOAddIndicesType(builder *flatbuffers.Builder, indicesType flatbuffers.UOffsetT)
	 func SparseTensorIndexCOOAddIsCanonical(builder *flatbuffers.Builder, isCanonical bool)
	 func SparseTensorIndexCOOEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func SparseTensorIndexCOOStart(builder *flatbuffers.Builder)
	 func SparseTensorIndexCOOStartIndicesStridesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func SparseTensorIndexCSFAddAxisOrder(builder *flatbuffers.Builder, axisOrder flatbuffers.UOffsetT)
	 func SparseTensorIndexCSFAddIndicesBuffers(builder *flatbuffers.Builder, indicesBuffers flatbuffers.UOffsetT)
	 func SparseTensorIndexCSFAddIndicesType(builder *flatbuffers.Builder, indicesType flatbuffers.UOffsetT)
	 func SparseTensorIndexCSFAddIndptrBuffers(builder *flatbuffers.Builder, indptrBuffers flatbuffers.UOffsetT)
	 func SparseTensorIndexCSFAddIndptrType(builder *flatbuffers.Builder, indptrType flatbuffers.UOffsetT)
	 func SparseTensorIndexCSFEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func SparseTensorIndexCSFStart(builder *flatbuffers.Builder)
	 func SparseTensorIndexCSFStartAxisOrderVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func SparseTensorIndexCSFStartIndicesBuffersVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func SparseTensorIndexCSFStartIndptrBuffersVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func SparseTensorStart(builder *flatbuffers.Builder)
		/ The location and size of the tensor's data

	 func SparseTensorStartShapeVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func Struct_End(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func Struct_Start(builder *flatbuffers.Builder)
	 func TensorAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT)
	 func TensorAddShape(builder *flatbuffers.Builder, shape flatbuffers.UOffsetT)
	 func TensorAddStrides(builder *flatbuffers.Builder, strides flatbuffers.UOffsetT)
	 func TensorAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT)
	 func TensorAddTypeType(builder *flatbuffers.Builder, typeType Type)
	 func TensorDimAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT)
	 func TensorDimAddSize(builder *flatbuffers.Builder, size int64)
	 func TensorDimEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func TensorDimStart(builder *flatbuffers.Builder)
		/ Name of the dimension, optional

	 func TensorEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func TensorStart(builder *flatbuffers.Builder)
		/ The location and size of the tensor's data

	 func TensorStartShapeVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func TensorStartStridesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func TimeAddBitWidth(builder *flatbuffers.Builder, bitWidth int32)
	 func TimeAddUnit(builder *flatbuffers.Builder, unit TimeUnit)
	 func TimeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func TimestampAddTimezone(builder *flatbuffers.Builder, timezone flatbuffers.UOffsetT)
	 func TimestampAddUnit(builder *flatbuffers.Builder, unit TimeUnit)
	 func TimestampEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func TimestampStart(builder *flatbuffers.Builder)
		/ The timezone is an optional string indicating the name of a timezone,
		/ one of:
		/
		/ * As used in the Olson timezone database (the "tz database" or
		/   "tzdata"), such as "America/New_York".
		/ * An absolute timezone offset of the form "+XX:XX" or "-XX:XX",
		/   such as "+07:30".
		/
		/ Whether a timezone string is present indicates different semantics about
		/ the data (see above).

	 func TimeStart(builder *flatbuffers.Builder)
	 func UnionAddMode(builder *flatbuffers.Builder, mode UnionMode)
	 func UnionAddTypeIds(builder *flatbuffers.Builder, typeIds flatbuffers.UOffsetT)
	 func UnionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func UnionStart(builder *flatbuffers.Builder)
	 func UnionStartTypeIdsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT
	 func Utf8End(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func Utf8Start(builder *flatbuffers.Builder)
	 func Utf8ViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT
	 func Utf8ViewStart(builder *flatbuffers.Builder)
Package-Level Variables (total 30)

	  var EnumNamesBodyCompressionMethod map[BodyCompressionMethod]string
	  var EnumNamesCompressionType map[CompressionType]string
	  var EnumNamesDateUnit map[DateUnit]string
	  var EnumNamesDictionaryKind map[DictionaryKind]string
	  var EnumNamesEndianness map[Endianness]string
	  var EnumNamesFeature map[Feature]string
	  var EnumNamesIntervalUnit map[IntervalUnit]string
	  var EnumNamesMessageHeader map[MessageHeader]string
	  var EnumNamesMetadataVersion map[MetadataVersion]string
	  var EnumNamesPrecision map[Precision]string
	  var EnumNamesSparseMatrixCompressedAxis map[SparseMatrixCompressedAxis]string
	  var EnumNamesSparseTensorIndex map[SparseTensorIndex]string
	  var EnumNamesTimeUnit map[TimeUnit]string
	  var EnumNamesType map[Type]string
	  var EnumNamesUnionMode map[UnionMode]string
	  var EnumValuesBodyCompressionMethod map[string]BodyCompressionMethod
	  var EnumValuesCompressionType map[string]CompressionType
	  var EnumValuesDateUnit map[string]DateUnit
	  var EnumValuesDictionaryKind map[string]DictionaryKind
	  var EnumValuesEndianness map[string]Endianness
	  var EnumValuesFeature map[string]Feature
	  var EnumValuesIntervalUnit map[string]IntervalUnit
	  var EnumValuesMessageHeader map[string]MessageHeader
	  var EnumValuesMetadataVersion map[string]MetadataVersion
	  var EnumValuesPrecision map[string]Precision
	  var EnumValuesSparseMatrixCompressedAxis map[string]SparseMatrixCompressedAxis
	  var EnumValuesSparseTensorIndex map[string]SparseTensorIndex
	  var EnumValuesTimeUnit map[string]TimeUnit
	  var EnumValuesType map[string]Type
	  var EnumValuesUnionMode map[string]UnionMode
Package-Level Constants (total 67)

	const BodyCompressionMethodBUFFER BodyCompressionMethod = 0
		/ Each constituent buffer is first compressed with the indicated
		/ compressor, and then written with the uncompressed length in the first 8
		/ bytes as a 64-bit little-endian signed integer followed by the compressed
		/ buffer bytes (and then padding as required by the protocol). The
		/ uncompressed length may be set to -1 to indicate that the data that
		/ follows is not compressed, which can be useful for cases where
		/ compression does not yield appreciable savings.

	const CompressionTypeLZ4_FRAME CompressionType = 0
	const CompressionTypeZSTD CompressionType = 1
	const DateUnitDAY DateUnit = 0
	const DateUnitMILLISECOND DateUnit = 1
	const DictionaryKindDenseArray DictionaryKind = 0
	const EndiannessBig Endianness = 1
	const EndiannessLittle Endianness = 0
	const FeatureCOMPRESSED_BODY Feature = 2
		/ The stream makes use of compressed bodies as described
		/ in Message.fbs.

	const FeatureDICTIONARY_REPLACEMENT Feature = 1
		/ The stream makes use of multiple full dictionaries with the
		/ same ID and assumes clients implement dictionary replacement
		/ correctly.

	const FeatureUNUSED Feature = 0
		/ Needed to make flatbuffers happy.

	const IntervalUnitDAY_TIME IntervalUnit = 1
	const IntervalUnitMONTH_DAY_NANO IntervalUnit = 2
	const IntervalUnitYEAR_MONTH IntervalUnit = 0
	const MessageHeaderDictionaryBatch MessageHeader = 2
	const MessageHeaderNONE MessageHeader = 0
	const MessageHeaderRecordBatch MessageHeader = 3
	const MessageHeaderSchema MessageHeader = 1
	const MessageHeaderSparseTensor MessageHeader = 5
	const MessageHeaderTensor MessageHeader = 4
	const MetadataVersionV1 MetadataVersion = 0
		/ 0.1.0 (October 2016).

	const MetadataVersionV2 MetadataVersion = 1
		/ 0.2.0 (February 2017). Non-backwards compatible with V1.

	const MetadataVersionV3 MetadataVersion = 2
		/ 0.3.0 -> 0.7.1 (May - December 2017). Non-backwards compatible with V2.

	const MetadataVersionV4 MetadataVersion = 3
		/ >= 0.8.0 (December 2017). Non-backwards compatible with V3.

	const MetadataVersionV5 MetadataVersion = 4
		/ >= 1.0.0 (July 2020). Backwards compatible with V4 (V5 readers can read V4
		/ metadata and IPC messages). Implementations are recommended to provide a
		/ V4 compatibility mode with V5 format changes disabled.
		/
		/ Incompatible changes between V4 and V5:
		/ - Union buffer layout has changed. In V5, Unions don't have a validity
		/   bitmap buffer.

	const PrecisionDOUBLE Precision = 2
	const PrecisionHALF Precision = 0
	const PrecisionSINGLE Precision = 1
	const SparseMatrixCompressedAxisColumn SparseMatrixCompressedAxis = 1
	const SparseMatrixCompressedAxisRow SparseMatrixCompressedAxis = 0
	const SparseTensorIndexNONE SparseTensorIndex = 0
	const SparseTensorIndexSparseMatrixIndexCSX SparseTensorIndex = 2
	const SparseTensorIndexSparseTensorIndexCOO SparseTensorIndex = 1
	const SparseTensorIndexSparseTensorIndexCSF SparseTensorIndex = 3
	const TimeUnitMICROSECOND TimeUnit = 2
	const TimeUnitMILLISECOND TimeUnit = 1
	const TimeUnitNANOSECOND TimeUnit = 3
	const TimeUnitSECOND TimeUnit = 0
	const TypeBinary Type = 4
	const TypeBinaryView Type = 23
	const TypeBool Type = 6
	const TypeDate Type = 8
	const TypeDecimal Type = 7
	const TypeDuration Type = 18
	const TypeFixedSizeBinary Type = 15
	const TypeFixedSizeList Type = 16
	const TypeFloatingPoint Type = 3
	const TypeInt Type = 2
	const TypeInterval Type = 11
	const TypeLargeBinary Type = 19
	const TypeLargeList Type = 21
	const TypeLargeListView Type = 26
	const TypeLargeUtf8 Type = 20
	const TypeList Type = 12
	const TypeListView Type = 25
	const TypeMap Type = 17
	const TypeNONE Type = 0
	const TypeNull Type = 1
	const TypeRunEndEncoded Type = 22
	const TypeStruct_ Type = 13
	const TypeTime Type = 9
	const TypeTimestamp Type = 10
	const TypeUnion Type = 14
	const TypeUtf8 Type = 5
	const TypeUtf8View Type = 24
	const UnionModeDense UnionMode = 1
	const UnionModeSparse UnionMode = 0

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.