# Generated by using data-raw/codegen.R -> do not edit by hand

is_altrep_int_nonull <- function(x){
    .Call(`_arrow_is_altrep_int_nonull`, x)
}

is_altrep_dbl_nonull <- function(x){
    .Call(`_arrow_is_altrep_dbl_nonull`, x)
}

Array__Slice1 <- function(array, offset){
    .Call(`_arrow_Array__Slice1`, array, offset)
}

Array__Slice2 <- function(array, offset, length){
    .Call(`_arrow_Array__Slice2`, array, offset, length)
}

Array__IsNull <- function(x, i){
    .Call(`_arrow_Array__IsNull`, x, i)
}

Array__IsValid <- function(x, i){
    .Call(`_arrow_Array__IsValid`, x, i)
}

Array__length <- function(x){
    .Call(`_arrow_Array__length`, x)
}

Array__offset <- function(x){
    .Call(`_arrow_Array__offset`, x)
}

Array__null_count <- function(x){
    .Call(`_arrow_Array__null_count`, x)
}

Array__type <- function(x){
    .Call(`_arrow_Array__type`, x)
}

Array__ToString <- function(x){
    .Call(`_arrow_Array__ToString`, x)
}

Array__type_id <- function(x){
    .Call(`_arrow_Array__type_id`, x)
}

Array__Equals <- function(lhs, rhs){
    .Call(`_arrow_Array__Equals`, lhs, rhs)
}

Array__ApproxEquals <- function(lhs, rhs){
    .Call(`_arrow_Array__ApproxEquals`, lhs, rhs)
}

Array__Diff <- function(lhs, rhs){
    .Call(`_arrow_Array__Diff`, lhs, rhs)
}

Array__data <- function(array){
    .Call(`_arrow_Array__data`, array)
}

Array__RangeEquals <- function(self, other, start_idx, end_idx, other_start_idx){
    .Call(`_arrow_Array__RangeEquals`, self, other, start_idx, end_idx, other_start_idx)
}

Array__View <- function(array, type){
    .Call(`_arrow_Array__View`, array, type)
}

Array__Validate <- function(array){
    invisible(.Call(`_arrow_Array__Validate`, array))
}

DictionaryArray__indices <- function(array){
    .Call(`_arrow_DictionaryArray__indices`, array)
}

DictionaryArray__dictionary <- function(array){
    .Call(`_arrow_DictionaryArray__dictionary`, array)
}

StructArray__field <- function(array, i){
    .Call(`_arrow_StructArray__field`, array, i)
}

StructArray__GetFieldByName <- function(array, name){
    .Call(`_arrow_StructArray__GetFieldByName`, array, name)
}

StructArray__Flatten <- function(array){
    .Call(`_arrow_StructArray__Flatten`, array)
}

ListArray__value_type <- function(array){
    .Call(`_arrow_ListArray__value_type`, array)
}

LargeListArray__value_type <- function(array){
    .Call(`_arrow_LargeListArray__value_type`, array)
}

ListArray__values <- function(array){
    .Call(`_arrow_ListArray__values`, array)
}

LargeListArray__values <- function(array){
    .Call(`_arrow_LargeListArray__values`, array)
}

ListArray__value_length <- function(array, i){
    .Call(`_arrow_ListArray__value_length`, array, i)
}

LargeListArray__value_length <- function(array, i){
    .Call(`_arrow_LargeListArray__value_length`, array, i)
}

FixedSizeListArray__value_length <- function(array, i){
    .Call(`_arrow_FixedSizeListArray__value_length`, array, i)
}

ListArray__value_offset <- function(array, i){
    .Call(`_arrow_ListArray__value_offset`, array, i)
}

LargeListArray__value_offset <- function(array, i){
    .Call(`_arrow_LargeListArray__value_offset`, array, i)
}

FixedSizeListArray__value_offset <- function(array, i){
    .Call(`_arrow_FixedSizeListArray__value_offset`, array, i)
}

ListArray__raw_value_offsets <- function(array){
    .Call(`_arrow_ListArray__raw_value_offsets`, array)
}

LargeListArray__raw_value_offsets <- function(array){
    .Call(`_arrow_LargeListArray__raw_value_offsets`, array)
}

Array__as_vector <- function(array){
    .Call(`_arrow_Array__as_vector`, array)
}

ChunkedArray__as_vector <- function(chunked_array, use_threads){
    .Call(`_arrow_ChunkedArray__as_vector`, chunked_array, use_threads)
}

RecordBatch__to_dataframe <- function(batch, use_threads){
    .Call(`_arrow_RecordBatch__to_dataframe`, batch, use_threads)
}

Table__to_dataframe <- function(table, use_threads){
    .Call(`_arrow_Table__to_dataframe`, table, use_threads)
}

ArrayData__get_type <- function(x){
    .Call(`_arrow_ArrayData__get_type`, x)
}

ArrayData__get_length <- function(x){
    .Call(`_arrow_ArrayData__get_length`, x)
}

ArrayData__get_null_count <- function(x){
    .Call(`_arrow_ArrayData__get_null_count`, x)
}

ArrayData__get_offset <- function(x){
    .Call(`_arrow_ArrayData__get_offset`, x)
}

ArrayData__buffers <- function(x){
    .Call(`_arrow_ArrayData__buffers`, x)
}

Buffer__is_mutable <- function(buffer){
    .Call(`_arrow_Buffer__is_mutable`, buffer)
}

Buffer__ZeroPadding <- function(buffer){
    invisible(.Call(`_arrow_Buffer__ZeroPadding`, buffer))
}

Buffer__capacity <- function(buffer){
    .Call(`_arrow_Buffer__capacity`, buffer)
}

Buffer__size <- function(buffer){
    .Call(`_arrow_Buffer__size`, buffer)
}

r___RBuffer__initialize <- function(x){
    .Call(`_arrow_r___RBuffer__initialize`, x)
}

Buffer__data <- function(buffer){
    .Call(`_arrow_Buffer__data`, buffer)
}

Buffer__Equals <- function(x, y){
    .Call(`_arrow_Buffer__Equals`, x, y)
}

ChunkedArray__length <- function(chunked_array){
    .Call(`_arrow_ChunkedArray__length`, chunked_array)
}

ChunkedArray__null_count <- function(chunked_array){
    .Call(`_arrow_ChunkedArray__null_count`, chunked_array)
}

ChunkedArray__num_chunks <- function(chunked_array){
    .Call(`_arrow_ChunkedArray__num_chunks`, chunked_array)
}

ChunkedArray__chunk <- function(chunked_array, i){
    .Call(`_arrow_ChunkedArray__chunk`, chunked_array, i)
}

ChunkedArray__chunks <- function(chunked_array){
    .Call(`_arrow_ChunkedArray__chunks`, chunked_array)
}

ChunkedArray__type <- function(chunked_array){
    .Call(`_arrow_ChunkedArray__type`, chunked_array)
}

ChunkedArray__Slice1 <- function(chunked_array, offset){
    .Call(`_arrow_ChunkedArray__Slice1`, chunked_array, offset)
}

ChunkedArray__Slice2 <- function(chunked_array, offset, length){
    .Call(`_arrow_ChunkedArray__Slice2`, chunked_array, offset, length)
}

ChunkedArray__View <- function(array, type){
    .Call(`_arrow_ChunkedArray__View`, array, type)
}

ChunkedArray__Validate <- function(chunked_array){
    invisible(.Call(`_arrow_ChunkedArray__Validate`, chunked_array))
}

ChunkedArray__Equals <- function(x, y){
    .Call(`_arrow_ChunkedArray__Equals`, x, y)
}

ChunkedArray__ToString <- function(x){
    .Call(`_arrow_ChunkedArray__ToString`, x)
}

ChunkedArray__from_list <- function(chunks, s_type){
    .Call(`_arrow_ChunkedArray__from_list`, chunks, s_type)
}

util___Codec__Create <- function(codec, compression_level){
    .Call(`_arrow_util___Codec__Create`, codec, compression_level)
}

util___Codec__name <- function(codec){
    .Call(`_arrow_util___Codec__name`, codec)
}

util___Codec__IsAvailable <- function(codec){
    .Call(`_arrow_util___Codec__IsAvailable`, codec)
}

io___CompressedOutputStream__Make <- function(codec, raw){
    .Call(`_arrow_io___CompressedOutputStream__Make`, codec, raw)
}

io___CompressedInputStream__Make <- function(codec, raw){
    .Call(`_arrow_io___CompressedInputStream__Make`, codec, raw)
}

RecordBatch__cast <- function(batch, schema, options){
    .Call(`_arrow_RecordBatch__cast`, batch, schema, options)
}

Table__cast <- function(table, schema, options){
    .Call(`_arrow_Table__cast`, table, schema, options)
}

compute__CallFunction <- function(func_name, args, options){
    .Call(`_arrow_compute__CallFunction`, func_name, args, options)
}

compute__GroupBy <- function(arguments, keys, options){
    .Call(`_arrow_compute__GroupBy`, arguments, keys, options)
}

compute__GetFunctionNames <- function(){
    .Call(`_arrow_compute__GetFunctionNames`)
}

build_info <- function(){
    .Call(`_arrow_build_info`)
}

runtime_info <- function(){
    .Call(`_arrow_runtime_info`)
}

csv___WriteOptions__initialize <- function(options){
    .Call(`_arrow_csv___WriteOptions__initialize`, options)
}

csv___ReadOptions__initialize <- function(options){
    .Call(`_arrow_csv___ReadOptions__initialize`, options)
}

csv___ParseOptions__initialize <- function(options){
    .Call(`_arrow_csv___ParseOptions__initialize`, options)
}

csv___ReadOptions__column_names <- function(options){
    .Call(`_arrow_csv___ReadOptions__column_names`, options)
}

csv___ConvertOptions__initialize <- function(options){
    .Call(`_arrow_csv___ConvertOptions__initialize`, options)
}

csv___TableReader__Make <- function(input, read_options, parse_options, convert_options){
    .Call(`_arrow_csv___TableReader__Make`, input, read_options, parse_options, convert_options)
}

csv___TableReader__Read <- function(table_reader){
    .Call(`_arrow_csv___TableReader__Read`, table_reader)
}

TimestampParser__kind <- function(parser){
    .Call(`_arrow_TimestampParser__kind`, parser)
}

TimestampParser__format <- function(parser){
    .Call(`_arrow_TimestampParser__format`, parser)
}

TimestampParser__MakeStrptime <- function(format){
    .Call(`_arrow_TimestampParser__MakeStrptime`, format)
}

TimestampParser__MakeISO8601 <- function(){
    .Call(`_arrow_TimestampParser__MakeISO8601`)
}

csv___WriteCSV__Table <- function(table, write_options, stream){
    invisible(.Call(`_arrow_csv___WriteCSV__Table`, table, write_options, stream))
}

csv___WriteCSV__RecordBatch <- function(record_batch, write_options, stream){
    invisible(.Call(`_arrow_csv___WriteCSV__RecordBatch`, record_batch, write_options, stream))
}

dataset___Dataset__NewScan <- function(ds){
    .Call(`_arrow_dataset___Dataset__NewScan`, ds)
}

dataset___Dataset__schema <- function(dataset){
    .Call(`_arrow_dataset___Dataset__schema`, dataset)
}

dataset___Dataset__type_name <- function(dataset){
    .Call(`_arrow_dataset___Dataset__type_name`, dataset)
}

dataset___Dataset__ReplaceSchema <- function(dataset, schm){
    .Call(`_arrow_dataset___Dataset__ReplaceSchema`, dataset, schm)
}

dataset___UnionDataset__create <- function(datasets, schm){
    .Call(`_arrow_dataset___UnionDataset__create`, datasets, schm)
}

dataset___InMemoryDataset__create <- function(table){
    .Call(`_arrow_dataset___InMemoryDataset__create`, table)
}

dataset___UnionDataset__children <- function(ds){
    .Call(`_arrow_dataset___UnionDataset__children`, ds)
}

dataset___FileSystemDataset__format <- function(dataset){
    .Call(`_arrow_dataset___FileSystemDataset__format`, dataset)
}

dataset___FileSystemDataset__filesystem <- function(dataset){
    .Call(`_arrow_dataset___FileSystemDataset__filesystem`, dataset)
}

dataset___FileSystemDataset__files <- function(dataset){
    .Call(`_arrow_dataset___FileSystemDataset__files`, dataset)
}

dataset___DatasetFactory__Finish1 <- function(factory, unify_schemas){
    .Call(`_arrow_dataset___DatasetFactory__Finish1`, factory, unify_schemas)
}

dataset___DatasetFactory__Finish2 <- function(factory, schema){
    .Call(`_arrow_dataset___DatasetFactory__Finish2`, factory, schema)
}

dataset___DatasetFactory__Inspect <- function(factory, unify_schemas){
    .Call(`_arrow_dataset___DatasetFactory__Inspect`, factory, unify_schemas)
}

dataset___UnionDatasetFactory__Make <- function(children){
    .Call(`_arrow_dataset___UnionDatasetFactory__Make`, children)
}

dataset___FileSystemDatasetFactory__Make0 <- function(fs, paths, format){
    .Call(`_arrow_dataset___FileSystemDatasetFactory__Make0`, fs, paths, format)
}

dataset___FileSystemDatasetFactory__Make2 <- function(fs, selector, format, partitioning){
    .Call(`_arrow_dataset___FileSystemDatasetFactory__Make2`, fs, selector, format, partitioning)
}

dataset___FileSystemDatasetFactory__Make1 <- function(fs, selector, format){
    .Call(`_arrow_dataset___FileSystemDatasetFactory__Make1`, fs, selector, format)
}

dataset___FileSystemDatasetFactory__Make3 <- function(fs, selector, format, factory){
    .Call(`_arrow_dataset___FileSystemDatasetFactory__Make3`, fs, selector, format, factory)
}

dataset___FileFormat__type_name <- function(format){
    .Call(`_arrow_dataset___FileFormat__type_name`, format)
}

dataset___FileFormat__DefaultWriteOptions <- function(fmt){
    .Call(`_arrow_dataset___FileFormat__DefaultWriteOptions`, fmt)
}

dataset___ParquetFileFormat__Make <- function(options, dict_columns){
    .Call(`_arrow_dataset___ParquetFileFormat__Make`, options, dict_columns)
}

dataset___FileWriteOptions__type_name <- function(options){
    .Call(`_arrow_dataset___FileWriteOptions__type_name`, options)
}

dataset___ParquetFileWriteOptions__update <- function(options, writer_props, arrow_writer_props){
    invisible(.Call(`_arrow_dataset___ParquetFileWriteOptions__update`, options, writer_props, arrow_writer_props))
}

dataset___IpcFileWriteOptions__update2 <- function(ipc_options, use_legacy_format, codec, metadata_version){
    invisible(.Call(`_arrow_dataset___IpcFileWriteOptions__update2`, ipc_options, use_legacy_format, codec, metadata_version))
}

dataset___IpcFileWriteOptions__update1 <- function(ipc_options, use_legacy_format, metadata_version){
    invisible(.Call(`_arrow_dataset___IpcFileWriteOptions__update1`, ipc_options, use_legacy_format, metadata_version))
}

dataset___CsvFileWriteOptions__update <- function(csv_options, write_options){
    invisible(.Call(`_arrow_dataset___CsvFileWriteOptions__update`, csv_options, write_options))
}

dataset___IpcFileFormat__Make <- function(){
    .Call(`_arrow_dataset___IpcFileFormat__Make`)
}

dataset___CsvFileFormat__Make <- function(parse_options, convert_options, read_options){
    .Call(`_arrow_dataset___CsvFileFormat__Make`, parse_options, convert_options, read_options)
}

dataset___FragmentScanOptions__type_name <- function(fragment_scan_options){
    .Call(`_arrow_dataset___FragmentScanOptions__type_name`, fragment_scan_options)
}

dataset___CsvFragmentScanOptions__Make <- function(convert_options, read_options){
    .Call(`_arrow_dataset___CsvFragmentScanOptions__Make`, convert_options, read_options)
}

dataset___ParquetFragmentScanOptions__Make <- function(use_buffered_stream, buffer_size, pre_buffer){
    .Call(`_arrow_dataset___ParquetFragmentScanOptions__Make`, use_buffered_stream, buffer_size, pre_buffer)
}

dataset___DirectoryPartitioning <- function(schm, segment_encoding){
    .Call(`_arrow_dataset___DirectoryPartitioning`, schm, segment_encoding)
}

dataset___DirectoryPartitioning__MakeFactory <- function(field_names, segment_encoding){
    .Call(`_arrow_dataset___DirectoryPartitioning__MakeFactory`, field_names, segment_encoding)
}

dataset___HivePartitioning <- function(schm, null_fallback, segment_encoding){
    .Call(`_arrow_dataset___HivePartitioning`, schm, null_fallback, segment_encoding)
}

dataset___HivePartitioning__MakeFactory <- function(null_fallback, segment_encoding){
    .Call(`_arrow_dataset___HivePartitioning__MakeFactory`, null_fallback, segment_encoding)
}

dataset___ScannerBuilder__ProjectNames <- function(sb, cols){
    invisible(.Call(`_arrow_dataset___ScannerBuilder__ProjectNames`, sb, cols))
}

dataset___ScannerBuilder__ProjectExprs <- function(sb, exprs, names){
    invisible(.Call(`_arrow_dataset___ScannerBuilder__ProjectExprs`, sb, exprs, names))
}

dataset___ScannerBuilder__Filter <- function(sb, expr){
    invisible(.Call(`_arrow_dataset___ScannerBuilder__Filter`, sb, expr))
}

dataset___ScannerBuilder__UseThreads <- function(sb, threads){
    invisible(.Call(`_arrow_dataset___ScannerBuilder__UseThreads`, sb, threads))
}

dataset___ScannerBuilder__UseAsync <- function(sb, use_async){
    invisible(.Call(`_arrow_dataset___ScannerBuilder__UseAsync`, sb, use_async))
}

dataset___ScannerBuilder__BatchSize <- function(sb, batch_size){
    invisible(.Call(`_arrow_dataset___ScannerBuilder__BatchSize`, sb, batch_size))
}

dataset___ScannerBuilder__FragmentScanOptions <- function(sb, options){
    invisible(.Call(`_arrow_dataset___ScannerBuilder__FragmentScanOptions`, sb, options))
}

dataset___ScannerBuilder__schema <- function(sb){
    .Call(`_arrow_dataset___ScannerBuilder__schema`, sb)
}

dataset___ScannerBuilder__Finish <- function(sb){
    .Call(`_arrow_dataset___ScannerBuilder__Finish`, sb)
}

dataset___Scanner__ToTable <- function(scanner){
    .Call(`_arrow_dataset___Scanner__ToTable`, scanner)
}

dataset___Scanner__ScanBatches <- function(scanner){
    .Call(`_arrow_dataset___Scanner__ScanBatches`, scanner)
}

dataset___Scanner__ToRecordBatchReader <- function(scanner){
    .Call(`_arrow_dataset___Scanner__ToRecordBatchReader`, scanner)
}

dataset___Scanner__head <- function(scanner, n){
    .Call(`_arrow_dataset___Scanner__head`, scanner, n)
}

dataset___Scanner__schema <- function(sc){
    .Call(`_arrow_dataset___Scanner__schema`, sc)
}

dataset___ScanTask__get_batches <- function(scan_task){
    .Call(`_arrow_dataset___ScanTask__get_batches`, scan_task)
}

dataset___Dataset__Write <- function(file_write_options, filesystem, base_dir, partitioning, basename_template, scanner){
    invisible(.Call(`_arrow_dataset___Dataset__Write`, file_write_options, filesystem, base_dir, partitioning, basename_template, scanner))
}

dataset___Scanner__TakeRows <- function(scanner, indices){
    .Call(`_arrow_dataset___Scanner__TakeRows`, scanner, indices)
}

dataset___Scanner__CountRows <- function(scanner){
    .Call(`_arrow_dataset___Scanner__CountRows`, scanner)
}

Int8__initialize <- function(){
    .Call(`_arrow_Int8__initialize`)
}

Int16__initialize <- function(){
    .Call(`_arrow_Int16__initialize`)
}

Int32__initialize <- function(){
    .Call(`_arrow_Int32__initialize`)
}

Int64__initialize <- function(){
    .Call(`_arrow_Int64__initialize`)
}

UInt8__initialize <- function(){
    .Call(`_arrow_UInt8__initialize`)
}

UInt16__initialize <- function(){
    .Call(`_arrow_UInt16__initialize`)
}

UInt32__initialize <- function(){
    .Call(`_arrow_UInt32__initialize`)
}

UInt64__initialize <- function(){
    .Call(`_arrow_UInt64__initialize`)
}

Float16__initialize <- function(){
    .Call(`_arrow_Float16__initialize`)
}

Float32__initialize <- function(){
    .Call(`_arrow_Float32__initialize`)
}

Float64__initialize <- function(){
    .Call(`_arrow_Float64__initialize`)
}

Boolean__initialize <- function(){
    .Call(`_arrow_Boolean__initialize`)
}

Utf8__initialize <- function(){
    .Call(`_arrow_Utf8__initialize`)
}

LargeUtf8__initialize <- function(){
    .Call(`_arrow_LargeUtf8__initialize`)
}

Binary__initialize <- function(){
    .Call(`_arrow_Binary__initialize`)
}

LargeBinary__initialize <- function(){
    .Call(`_arrow_LargeBinary__initialize`)
}

Date32__initialize <- function(){
    .Call(`_arrow_Date32__initialize`)
}

Date64__initialize <- function(){
    .Call(`_arrow_Date64__initialize`)
}

Null__initialize <- function(){
    .Call(`_arrow_Null__initialize`)
}

Decimal128Type__initialize <- function(precision, scale){
    .Call(`_arrow_Decimal128Type__initialize`, precision, scale)
}

FixedSizeBinary__initialize <- function(byte_width){
    .Call(`_arrow_FixedSizeBinary__initialize`, byte_width)
}

Timestamp__initialize <- function(unit, timezone){
    .Call(`_arrow_Timestamp__initialize`, unit, timezone)
}

Time32__initialize <- function(unit){
    .Call(`_arrow_Time32__initialize`, unit)
}

Time64__initialize <- function(unit){
    .Call(`_arrow_Time64__initialize`, unit)
}

list__ <- function(x){
    .Call(`_arrow_list__`, x)
}

large_list__ <- function(x){
    .Call(`_arrow_large_list__`, x)
}

fixed_size_list__ <- function(x, list_size){
    .Call(`_arrow_fixed_size_list__`, x, list_size)
}

struct__ <- function(fields){
    .Call(`_arrow_struct__`, fields)
}

DataType__ToString <- function(type){
    .Call(`_arrow_DataType__ToString`, type)
}

DataType__name <- function(type){
    .Call(`_arrow_DataType__name`, type)
}

DataType__Equals <- function(lhs, rhs){
    .Call(`_arrow_DataType__Equals`, lhs, rhs)
}

DataType__num_fields <- function(type){
    .Call(`_arrow_DataType__num_fields`, type)
}

DataType__fields <- function(type){
    .Call(`_arrow_DataType__fields`, type)
}

DataType__id <- function(type){
    .Call(`_arrow_DataType__id`, type)
}

ListType__ToString <- function(type){
    .Call(`_arrow_ListType__ToString`, type)
}

FixedWidthType__bit_width <- function(type){
    .Call(`_arrow_FixedWidthType__bit_width`, type)
}

DateType__unit <- function(type){
    .Call(`_arrow_DateType__unit`, type)
}

TimeType__unit <- function(type){
    .Call(`_arrow_TimeType__unit`, type)
}

DecimalType__precision <- function(type){
    .Call(`_arrow_DecimalType__precision`, type)
}

DecimalType__scale <- function(type){
    .Call(`_arrow_DecimalType__scale`, type)
}

TimestampType__timezone <- function(type){
    .Call(`_arrow_TimestampType__timezone`, type)
}

TimestampType__unit <- function(type){
    .Call(`_arrow_TimestampType__unit`, type)
}

DictionaryType__initialize <- function(index_type, value_type, ordered){
    .Call(`_arrow_DictionaryType__initialize`, index_type, value_type, ordered)
}

DictionaryType__index_type <- function(type){
    .Call(`_arrow_DictionaryType__index_type`, type)
}

DictionaryType__value_type <- function(type){
    .Call(`_arrow_DictionaryType__value_type`, type)
}

DictionaryType__name <- function(type){
    .Call(`_arrow_DictionaryType__name`, type)
}

DictionaryType__ordered <- function(type){
    .Call(`_arrow_DictionaryType__ordered`, type)
}

StructType__GetFieldByName <- function(type, name){
    .Call(`_arrow_StructType__GetFieldByName`, type, name)
}

StructType__GetFieldIndex <- function(type, name){
    .Call(`_arrow_StructType__GetFieldIndex`, type, name)
}

StructType__field_names <- function(type){
    .Call(`_arrow_StructType__field_names`, type)
}

ListType__value_field <- function(type){
    .Call(`_arrow_ListType__value_field`, type)
}

ListType__value_type <- function(type){
    .Call(`_arrow_ListType__value_type`, type)
}

LargeListType__value_field <- function(type){
    .Call(`_arrow_LargeListType__value_field`, type)
}

LargeListType__value_type <- function(type){
    .Call(`_arrow_LargeListType__value_type`, type)
}

FixedSizeListType__value_field <- function(type){
    .Call(`_arrow_FixedSizeListType__value_field`, type)
}

FixedSizeListType__value_type <- function(type){
    .Call(`_arrow_FixedSizeListType__value_type`, type)
}

FixedSizeListType__list_size <- function(type){
    .Call(`_arrow_FixedSizeListType__list_size`, type)
}

compute___expr__call <- function(func_name, argument_list, options){
    .Call(`_arrow_compute___expr__call`, func_name, argument_list, options)
}

compute___expr__field_ref <- function(name){
    .Call(`_arrow_compute___expr__field_ref`, name)
}

compute___expr__get_field_ref_name <- function(x){
    .Call(`_arrow_compute___expr__get_field_ref_name`, x)
}

compute___expr__scalar <- function(x){
    .Call(`_arrow_compute___expr__scalar`, x)
}

compute___expr__ToString <- function(x){
    .Call(`_arrow_compute___expr__ToString`, x)
}

compute___expr__type <- function(x, schema){
    .Call(`_arrow_compute___expr__type`, x, schema)
}

compute___expr__type_id <- function(x, schema){
    .Call(`_arrow_compute___expr__type_id`, x, schema)
}

ipc___WriteFeather__Table <- function(stream, table, version, chunk_size, compression, compression_level){
    invisible(.Call(`_arrow_ipc___WriteFeather__Table`, stream, table, version, chunk_size, compression, compression_level))
}

ipc___feather___Reader__version <- function(reader){
    .Call(`_arrow_ipc___feather___Reader__version`, reader)
}

ipc___feather___Reader__Read <- function(reader, columns){
    .Call(`_arrow_ipc___feather___Reader__Read`, reader, columns)
}

ipc___feather___Reader__Open <- function(stream){
    .Call(`_arrow_ipc___feather___Reader__Open`, stream)
}

ipc___feather___Reader__schema <- function(reader){
    .Call(`_arrow_ipc___feather___Reader__schema`, reader)
}

Field__initialize <- function(name, field, nullable){
    .Call(`_arrow_Field__initialize`, name, field, nullable)
}

Field__ToString <- function(field){
    .Call(`_arrow_Field__ToString`, field)
}

Field__name <- function(field){
    .Call(`_arrow_Field__name`, field)
}

Field__Equals <- function(field, other){
    .Call(`_arrow_Field__Equals`, field, other)
}

Field__nullable <- function(field){
    .Call(`_arrow_Field__nullable`, field)
}

Field__type <- function(field){
    .Call(`_arrow_Field__type`, field)
}

fs___FileInfo__type <- function(x){
    .Call(`_arrow_fs___FileInfo__type`, x)
}

fs___FileInfo__set_type <- function(x, type){
    invisible(.Call(`_arrow_fs___FileInfo__set_type`, x, type))
}

fs___FileInfo__path <- function(x){
    .Call(`_arrow_fs___FileInfo__path`, x)
}

fs___FileInfo__set_path <- function(x, path){
    invisible(.Call(`_arrow_fs___FileInfo__set_path`, x, path))
}

fs___FileInfo__size <- function(x){
    .Call(`_arrow_fs___FileInfo__size`, x)
}

fs___FileInfo__set_size <- function(x, size){
    invisible(.Call(`_arrow_fs___FileInfo__set_size`, x, size))
}

fs___FileInfo__base_name <- function(x){
    .Call(`_arrow_fs___FileInfo__base_name`, x)
}

fs___FileInfo__extension <- function(x){
    .Call(`_arrow_fs___FileInfo__extension`, x)
}

fs___FileInfo__mtime <- function(x){
    .Call(`_arrow_fs___FileInfo__mtime`, x)
}

fs___FileInfo__set_mtime <- function(x, time){
    invisible(.Call(`_arrow_fs___FileInfo__set_mtime`, x, time))
}

fs___FileSelector__base_dir <- function(selector){
    .Call(`_arrow_fs___FileSelector__base_dir`, selector)
}

fs___FileSelector__allow_not_found <- function(selector){
    .Call(`_arrow_fs___FileSelector__allow_not_found`, selector)
}

fs___FileSelector__recursive <- function(selector){
    .Call(`_arrow_fs___FileSelector__recursive`, selector)
}

fs___FileSelector__create <- function(base_dir, allow_not_found, recursive){
    .Call(`_arrow_fs___FileSelector__create`, base_dir, allow_not_found, recursive)
}

fs___FileSystem__GetTargetInfos_Paths <- function(file_system, paths){
    .Call(`_arrow_fs___FileSystem__GetTargetInfos_Paths`, file_system, paths)
}

fs___FileSystem__GetTargetInfos_FileSelector <- function(file_system, selector){
    .Call(`_arrow_fs___FileSystem__GetTargetInfos_FileSelector`, file_system, selector)
}

fs___FileSystem__CreateDir <- function(file_system, path, recursive){
    invisible(.Call(`_arrow_fs___FileSystem__CreateDir`, file_system, path, recursive))
}

fs___FileSystem__DeleteDir <- function(file_system, path){
    invisible(.Call(`_arrow_fs___FileSystem__DeleteDir`, file_system, path))
}

fs___FileSystem__DeleteDirContents <- function(file_system, path){
    invisible(.Call(`_arrow_fs___FileSystem__DeleteDirContents`, file_system, path))
}

fs___FileSystem__DeleteFile <- function(file_system, path){
    invisible(.Call(`_arrow_fs___FileSystem__DeleteFile`, file_system, path))
}

fs___FileSystem__DeleteFiles <- function(file_system, paths){
    invisible(.Call(`_arrow_fs___FileSystem__DeleteFiles`, file_system, paths))
}

fs___FileSystem__Move <- function(file_system, src, dest){
    invisible(.Call(`_arrow_fs___FileSystem__Move`, file_system, src, dest))
}

fs___FileSystem__CopyFile <- function(file_system, src, dest){
    invisible(.Call(`_arrow_fs___FileSystem__CopyFile`, file_system, src, dest))
}

fs___FileSystem__OpenInputStream <- function(file_system, path){
    .Call(`_arrow_fs___FileSystem__OpenInputStream`, file_system, path)
}

fs___FileSystem__OpenInputFile <- function(file_system, path){
    .Call(`_arrow_fs___FileSystem__OpenInputFile`, file_system, path)
}

fs___FileSystem__OpenOutputStream <- function(file_system, path){
    .Call(`_arrow_fs___FileSystem__OpenOutputStream`, file_system, path)
}

fs___FileSystem__OpenAppendStream <- function(file_system, path){
    .Call(`_arrow_fs___FileSystem__OpenAppendStream`, file_system, path)
}

fs___FileSystem__type_name <- function(file_system){
    .Call(`_arrow_fs___FileSystem__type_name`, file_system)
}

fs___LocalFileSystem__create <- function(){
    .Call(`_arrow_fs___LocalFileSystem__create`)
}

fs___SubTreeFileSystem__create <- function(base_path, base_fs){
    .Call(`_arrow_fs___SubTreeFileSystem__create`, base_path, base_fs)
}

fs___SubTreeFileSystem__base_fs <- function(file_system){
    .Call(`_arrow_fs___SubTreeFileSystem__base_fs`, file_system)
}

fs___SubTreeFileSystem__base_path <- function(file_system){
    .Call(`_arrow_fs___SubTreeFileSystem__base_path`, file_system)
}

fs___FileSystemFromUri <- function(path){
    .Call(`_arrow_fs___FileSystemFromUri`, path)
}

fs___CopyFiles <- function(source_fs, source_sel, destination_fs, destination_base_dir, chunk_size, use_threads){
    invisible(.Call(`_arrow_fs___CopyFiles`, source_fs, source_sel, destination_fs, destination_base_dir, chunk_size, use_threads))
}

fs___S3FileSystem__create <- function(anonymous, access_key, secret_key, session_token, role_arn, session_name, external_id, load_frequency, region, endpoint_override, scheme, background_writes){
    .Call(`_arrow_fs___S3FileSystem__create`, anonymous, access_key, secret_key, session_token, role_arn, session_name, external_id, load_frequency, region, endpoint_override, scheme, background_writes)
}

fs___S3FileSystem__region <- function(fs){
    .Call(`_arrow_fs___S3FileSystem__region`, fs)
}

io___Readable__Read <- function(x, nbytes){
    .Call(`_arrow_io___Readable__Read`, x, nbytes)
}

io___InputStream__Close <- function(x){
    invisible(.Call(`_arrow_io___InputStream__Close`, x))
}

io___OutputStream__Close <- function(x){
    invisible(.Call(`_arrow_io___OutputStream__Close`, x))
}

io___RandomAccessFile__GetSize <- function(x){
    .Call(`_arrow_io___RandomAccessFile__GetSize`, x)
}

io___RandomAccessFile__supports_zero_copy <- function(x){
    .Call(`_arrow_io___RandomAccessFile__supports_zero_copy`, x)
}

io___RandomAccessFile__Seek <- function(x, position){
    invisible(.Call(`_arrow_io___RandomAccessFile__Seek`, x, position))
}

io___RandomAccessFile__Tell <- function(x){
    .Call(`_arrow_io___RandomAccessFile__Tell`, x)
}

io___RandomAccessFile__Read0 <- function(x){
    .Call(`_arrow_io___RandomAccessFile__Read0`, x)
}

io___RandomAccessFile__ReadAt <- function(x, position, nbytes){
    .Call(`_arrow_io___RandomAccessFile__ReadAt`, x, position, nbytes)
}

io___MemoryMappedFile__Create <- function(path, size){
    .Call(`_arrow_io___MemoryMappedFile__Create`, path, size)
}

io___MemoryMappedFile__Open <- function(path, mode){
    .Call(`_arrow_io___MemoryMappedFile__Open`, path, mode)
}

io___MemoryMappedFile__Resize <- function(x, size){
    invisible(.Call(`_arrow_io___MemoryMappedFile__Resize`, x, size))
}

io___ReadableFile__Open <- function(path){
    .Call(`_arrow_io___ReadableFile__Open`, path)
}

io___BufferReader__initialize <- function(buffer){
    .Call(`_arrow_io___BufferReader__initialize`, buffer)
}

io___Writable__write <- function(stream, buf){
    invisible(.Call(`_arrow_io___Writable__write`, stream, buf))
}

io___OutputStream__Tell <- function(stream){
    .Call(`_arrow_io___OutputStream__Tell`, stream)
}

io___FileOutputStream__Open <- function(path){
    .Call(`_arrow_io___FileOutputStream__Open`, path)
}

io___BufferOutputStream__Create <- function(initial_capacity){
    .Call(`_arrow_io___BufferOutputStream__Create`, initial_capacity)
}

io___BufferOutputStream__capacity <- function(stream){
    .Call(`_arrow_io___BufferOutputStream__capacity`, stream)
}

io___BufferOutputStream__Finish <- function(stream){
    .Call(`_arrow_io___BufferOutputStream__Finish`, stream)
}

io___BufferOutputStream__Tell <- function(stream){
    .Call(`_arrow_io___BufferOutputStream__Tell`, stream)
}

io___BufferOutputStream__Write <- function(stream, bytes){
    invisible(.Call(`_arrow_io___BufferOutputStream__Write`, stream, bytes))
}

json___ReadOptions__initialize <- function(use_threads, block_size){
    .Call(`_arrow_json___ReadOptions__initialize`, use_threads, block_size)
}

json___ParseOptions__initialize1 <- function(newlines_in_values){
    .Call(`_arrow_json___ParseOptions__initialize1`, newlines_in_values)
}

json___ParseOptions__initialize2 <- function(newlines_in_values, explicit_schema){
    .Call(`_arrow_json___ParseOptions__initialize2`, newlines_in_values, explicit_schema)
}

json___TableReader__Make <- function(input, read_options, parse_options){
    .Call(`_arrow_json___TableReader__Make`, input, read_options, parse_options)
}

json___TableReader__Read <- function(table_reader){
    .Call(`_arrow_json___TableReader__Read`, table_reader)
}

MemoryPool__default <- function(){
    .Call(`_arrow_MemoryPool__default`)
}

MemoryPool__bytes_allocated <- function(pool){
    .Call(`_arrow_MemoryPool__bytes_allocated`, pool)
}

MemoryPool__max_memory <- function(pool){
    .Call(`_arrow_MemoryPool__max_memory`, pool)
}

MemoryPool__backend_name <- function(pool){
    .Call(`_arrow_MemoryPool__backend_name`, pool)
}

supported_memory_backends <- function(){
    .Call(`_arrow_supported_memory_backends`)
}

ipc___Message__body_length <- function(message){
    .Call(`_arrow_ipc___Message__body_length`, message)
}

ipc___Message__metadata <- function(message){
    .Call(`_arrow_ipc___Message__metadata`, message)
}

ipc___Message__body <- function(message){
    .Call(`_arrow_ipc___Message__body`, message)
}

ipc___Message__Verify <- function(message){
    .Call(`_arrow_ipc___Message__Verify`, message)
}

ipc___Message__type <- function(message){
    .Call(`_arrow_ipc___Message__type`, message)
}

ipc___Message__Equals <- function(x, y){
    .Call(`_arrow_ipc___Message__Equals`, x, y)
}

ipc___ReadRecordBatch__Message__Schema <- function(message, schema){
    .Call(`_arrow_ipc___ReadRecordBatch__Message__Schema`, message, schema)
}

ipc___ReadSchema_InputStream <- function(stream){
    .Call(`_arrow_ipc___ReadSchema_InputStream`, stream)
}

ipc___ReadSchema_Message <- function(message){
    .Call(`_arrow_ipc___ReadSchema_Message`, message)
}

ipc___MessageReader__Open <- function(stream){
    .Call(`_arrow_ipc___MessageReader__Open`, stream)
}

ipc___MessageReader__ReadNextMessage <- function(reader){
    .Call(`_arrow_ipc___MessageReader__ReadNextMessage`, reader)
}

ipc___ReadMessage <- function(stream){
    .Call(`_arrow_ipc___ReadMessage`, stream)
}

parquet___arrow___ArrowReaderProperties__Make <- function(use_threads){
    .Call(`_arrow_parquet___arrow___ArrowReaderProperties__Make`, use_threads)
}

parquet___arrow___ArrowReaderProperties__set_use_threads <- function(properties, use_threads){
    invisible(.Call(`_arrow_parquet___arrow___ArrowReaderProperties__set_use_threads`, properties, use_threads))
}

parquet___arrow___ArrowReaderProperties__get_use_threads <- function(properties, use_threads){
    .Call(`_arrow_parquet___arrow___ArrowReaderProperties__get_use_threads`, properties, use_threads)
}

parquet___arrow___ArrowReaderProperties__get_read_dictionary <- function(properties, column_index){
    .Call(`_arrow_parquet___arrow___ArrowReaderProperties__get_read_dictionary`, properties, column_index)
}

parquet___arrow___ArrowReaderProperties__set_read_dictionary <- function(properties, column_index, read_dict){
    invisible(.Call(`_arrow_parquet___arrow___ArrowReaderProperties__set_read_dictionary`, properties, column_index, read_dict))
}

parquet___arrow___FileReader__OpenFile <- function(file, props){
    .Call(`_arrow_parquet___arrow___FileReader__OpenFile`, file, props)
}

parquet___arrow___FileReader__ReadTable1 <- function(reader){
    .Call(`_arrow_parquet___arrow___FileReader__ReadTable1`, reader)
}

parquet___arrow___FileReader__ReadTable2 <- function(reader, column_indices){
    .Call(`_arrow_parquet___arrow___FileReader__ReadTable2`, reader, column_indices)
}

parquet___arrow___FileReader__ReadRowGroup1 <- function(reader, i){
    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroup1`, reader, i)
}

parquet___arrow___FileReader__ReadRowGroup2 <- function(reader, i, column_indices){
    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroup2`, reader, i, column_indices)
}

parquet___arrow___FileReader__ReadRowGroups1 <- function(reader, row_groups){
    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroups1`, reader, row_groups)
}

parquet___arrow___FileReader__ReadRowGroups2 <- function(reader, row_groups, column_indices){
    .Call(`_arrow_parquet___arrow___FileReader__ReadRowGroups2`, reader, row_groups, column_indices)
}

parquet___arrow___FileReader__num_rows <- function(reader){
    .Call(`_arrow_parquet___arrow___FileReader__num_rows`, reader)
}

parquet___arrow___FileReader__num_columns <- function(reader){
    .Call(`_arrow_parquet___arrow___FileReader__num_columns`, reader)
}

parquet___arrow___FileReader__num_row_groups <- function(reader){
    .Call(`_arrow_parquet___arrow___FileReader__num_row_groups`, reader)
}

parquet___arrow___FileReader__ReadColumn <- function(reader, i){
    .Call(`_arrow_parquet___arrow___FileReader__ReadColumn`, reader, i)
}

parquet___ArrowWriterProperties___create <- function(allow_truncated_timestamps, use_deprecated_int96_timestamps, timestamp_unit){
    .Call(`_arrow_parquet___ArrowWriterProperties___create`, allow_truncated_timestamps, use_deprecated_int96_timestamps, timestamp_unit)
}

parquet___WriterProperties___Builder__create <- function(){
    .Call(`_arrow_parquet___WriterProperties___Builder__create`)
}

parquet___WriterProperties___Builder__version <- function(builder, version){
    invisible(.Call(`_arrow_parquet___WriterProperties___Builder__version`, builder, version))
}

parquet___ArrowWriterProperties___Builder__set_compressions <- function(builder, paths, types){
    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_compressions`, builder, paths, types))
}

parquet___ArrowWriterProperties___Builder__set_compression_levels <- function(builder, paths, levels){
    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_compression_levels`, builder, paths, levels))
}

parquet___ArrowWriterProperties___Builder__set_use_dictionary <- function(builder, paths, use_dictionary){
    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_use_dictionary`, builder, paths, use_dictionary))
}

parquet___ArrowWriterProperties___Builder__set_write_statistics <- function(builder, paths, write_statistics){
    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__set_write_statistics`, builder, paths, write_statistics))
}

parquet___ArrowWriterProperties___Builder__data_page_size <- function(builder, data_page_size){
    invisible(.Call(`_arrow_parquet___ArrowWriterProperties___Builder__data_page_size`, builder, data_page_size))
}

parquet___WriterProperties___Builder__build <- function(builder){
    .Call(`_arrow_parquet___WriterProperties___Builder__build`, builder)
}

parquet___arrow___ParquetFileWriter__Open <- function(schema, sink, properties, arrow_properties){
    .Call(`_arrow_parquet___arrow___ParquetFileWriter__Open`, schema, sink, properties, arrow_properties)
}

parquet___arrow___FileWriter__WriteTable <- function(writer, table, chunk_size){
    invisible(.Call(`_arrow_parquet___arrow___FileWriter__WriteTable`, writer, table, chunk_size))
}

parquet___arrow___FileWriter__Close <- function(writer){
    invisible(.Call(`_arrow_parquet___arrow___FileWriter__Close`, writer))
}

parquet___arrow___WriteTable <- function(table, sink, properties, arrow_properties){
    invisible(.Call(`_arrow_parquet___arrow___WriteTable`, table, sink, properties, arrow_properties))
}

parquet___arrow___FileReader__GetSchema <- function(reader){
    .Call(`_arrow_parquet___arrow___FileReader__GetSchema`, reader)
}

allocate_arrow_schema <- function(){
    .Call(`_arrow_allocate_arrow_schema`)
}

delete_arrow_schema <- function(ptr){
    invisible(.Call(`_arrow_delete_arrow_schema`, ptr))
}

allocate_arrow_array <- function(){
    .Call(`_arrow_allocate_arrow_array`)
}

delete_arrow_array <- function(ptr){
    invisible(.Call(`_arrow_delete_arrow_array`, ptr))
}

allocate_arrow_array_stream <- function(){
    .Call(`_arrow_allocate_arrow_array_stream`)
}

delete_arrow_array_stream <- function(ptr){
    invisible(.Call(`_arrow_delete_arrow_array_stream`, ptr))
}

ImportArray <- function(array, schema){
    .Call(`_arrow_ImportArray`, array, schema)
}

ImportRecordBatch <- function(array, schema){
    .Call(`_arrow_ImportRecordBatch`, array, schema)
}

ImportSchema <- function(schema){
    .Call(`_arrow_ImportSchema`, schema)
}

ImportField <- function(field){
    .Call(`_arrow_ImportField`, field)
}

ImportType <- function(type){
    .Call(`_arrow_ImportType`, type)
}

ImportRecordBatchReader <- function(stream){
    .Call(`_arrow_ImportRecordBatchReader`, stream)
}

ExportType <- function(type, ptr){
    invisible(.Call(`_arrow_ExportType`, type, ptr))
}

ExportField <- function(field, ptr){
    invisible(.Call(`_arrow_ExportField`, field, ptr))
}

ExportSchema <- function(schema, ptr){
    invisible(.Call(`_arrow_ExportSchema`, schema, ptr))
}

ExportArray <- function(array, array_ptr, schema_ptr){
    invisible(.Call(`_arrow_ExportArray`, array, array_ptr, schema_ptr))
}

ExportRecordBatch <- function(batch, array_ptr, schema_ptr){
    invisible(.Call(`_arrow_ExportRecordBatch`, batch, array_ptr, schema_ptr))
}

ExportRecordBatchReader <- function(reader, stream_ptr){
    invisible(.Call(`_arrow_ExportRecordBatchReader`, reader, stream_ptr))
}

Table__from_dots <- function(lst, schema_sxp, use_threads){
    .Call(`_arrow_Table__from_dots`, lst, schema_sxp, use_threads)
}

vec_to_arrow <- function(x, s_type){
    .Call(`_arrow_vec_to_arrow`, x, s_type)
}

DictionaryArray__FromArrays <- function(type, indices, dict){
    .Call(`_arrow_DictionaryArray__FromArrays`, type, indices, dict)
}

RecordBatch__num_columns <- function(x){
    .Call(`_arrow_RecordBatch__num_columns`, x)
}

RecordBatch__num_rows <- function(x){
    .Call(`_arrow_RecordBatch__num_rows`, x)
}

RecordBatch__schema <- function(x){
    .Call(`_arrow_RecordBatch__schema`, x)
}

RecordBatch__RenameColumns <- function(batch, names){
    .Call(`_arrow_RecordBatch__RenameColumns`, batch, names)
}

RecordBatch__ReplaceSchemaMetadata <- function(x, metadata){
    .Call(`_arrow_RecordBatch__ReplaceSchemaMetadata`, x, metadata)
}

RecordBatch__columns <- function(batch){
    .Call(`_arrow_RecordBatch__columns`, batch)
}

RecordBatch__column <- function(batch, i){
    .Call(`_arrow_RecordBatch__column`, batch, i)
}

RecordBatch__GetColumnByName <- function(batch, name){
    .Call(`_arrow_RecordBatch__GetColumnByName`, batch, name)
}

RecordBatch__SelectColumns <- function(batch, indices){
    .Call(`_arrow_RecordBatch__SelectColumns`, batch, indices)
}

RecordBatch__Equals <- function(self, other, check_metadata){
    .Call(`_arrow_RecordBatch__Equals`, self, other, check_metadata)
}

RecordBatch__AddColumn <- function(batch, i, field, column){
    .Call(`_arrow_RecordBatch__AddColumn`, batch, i, field, column)
}

RecordBatch__SetColumn <- function(batch, i, field, column){
    .Call(`_arrow_RecordBatch__SetColumn`, batch, i, field, column)
}

RecordBatch__RemoveColumn <- function(batch, i){
    .Call(`_arrow_RecordBatch__RemoveColumn`, batch, i)
}

RecordBatch__column_name <- function(batch, i){
    .Call(`_arrow_RecordBatch__column_name`, batch, i)
}

RecordBatch__names <- function(batch){
    .Call(`_arrow_RecordBatch__names`, batch)
}

RecordBatch__Slice1 <- function(self, offset){
    .Call(`_arrow_RecordBatch__Slice1`, self, offset)
}

RecordBatch__Slice2 <- function(self, offset, length){
    .Call(`_arrow_RecordBatch__Slice2`, self, offset, length)
}

ipc___SerializeRecordBatch__Raw <- function(batch){
    .Call(`_arrow_ipc___SerializeRecordBatch__Raw`, batch)
}

ipc___ReadRecordBatch__InputStream__Schema <- function(stream, schema){
    .Call(`_arrow_ipc___ReadRecordBatch__InputStream__Schema`, stream, schema)
}

RecordBatch__from_arrays <- function(schema_sxp, lst){
    .Call(`_arrow_RecordBatch__from_arrays`, schema_sxp, lst)
}

RecordBatchReader__schema <- function(reader){
    .Call(`_arrow_RecordBatchReader__schema`, reader)
}

RecordBatchReader__ReadNext <- function(reader){
    .Call(`_arrow_RecordBatchReader__ReadNext`, reader)
}

RecordBatchReader__batches <- function(reader){
    .Call(`_arrow_RecordBatchReader__batches`, reader)
}

Table__from_RecordBatchReader <- function(reader){
    .Call(`_arrow_Table__from_RecordBatchReader`, reader)
}

ipc___RecordBatchStreamReader__Open <- function(stream){
    .Call(`_arrow_ipc___RecordBatchStreamReader__Open`, stream)
}

ipc___RecordBatchFileReader__schema <- function(reader){
    .Call(`_arrow_ipc___RecordBatchFileReader__schema`, reader)
}

ipc___RecordBatchFileReader__num_record_batches <- function(reader){
    .Call(`_arrow_ipc___RecordBatchFileReader__num_record_batches`, reader)
}

ipc___RecordBatchFileReader__ReadRecordBatch <- function(reader, i){
    .Call(`_arrow_ipc___RecordBatchFileReader__ReadRecordBatch`, reader, i)
}

ipc___RecordBatchFileReader__Open <- function(file){
    .Call(`_arrow_ipc___RecordBatchFileReader__Open`, file)
}

Table__from_RecordBatchFileReader <- function(reader){
    .Call(`_arrow_Table__from_RecordBatchFileReader`, reader)
}

ipc___RecordBatchFileReader__batches <- function(reader){
    .Call(`_arrow_ipc___RecordBatchFileReader__batches`, reader)
}

ipc___RecordBatchWriter__WriteRecordBatch <- function(batch_writer, batch){
    invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteRecordBatch`, batch_writer, batch))
}

ipc___RecordBatchWriter__WriteTable <- function(batch_writer, table){
    invisible(.Call(`_arrow_ipc___RecordBatchWriter__WriteTable`, batch_writer, table))
}

ipc___RecordBatchWriter__Close <- function(batch_writer){
    invisible(.Call(`_arrow_ipc___RecordBatchWriter__Close`, batch_writer))
}

ipc___RecordBatchFileWriter__Open <- function(stream, schema, use_legacy_format, metadata_version){
    .Call(`_arrow_ipc___RecordBatchFileWriter__Open`, stream, schema, use_legacy_format, metadata_version)
}

ipc___RecordBatchStreamWriter__Open <- function(stream, schema, use_legacy_format, metadata_version){
    .Call(`_arrow_ipc___RecordBatchStreamWriter__Open`, stream, schema, use_legacy_format, metadata_version)
}

Array__GetScalar <- function(x, i){
    .Call(`_arrow_Array__GetScalar`, x, i)
}

Scalar__ToString <- function(s){
    .Call(`_arrow_Scalar__ToString`, s)
}

StructScalar__field <- function(s, i){
    .Call(`_arrow_StructScalar__field`, s, i)
}

StructScalar__GetFieldByName <- function(s, name){
    .Call(`_arrow_StructScalar__GetFieldByName`, s, name)
}

Scalar__as_vector <- function(scalar){
    .Call(`_arrow_Scalar__as_vector`, scalar)
}

MakeArrayFromScalar <- function(scalar, n){
    .Call(`_arrow_MakeArrayFromScalar`, scalar, n)
}

Scalar__is_valid <- function(s){
    .Call(`_arrow_Scalar__is_valid`, s)
}

Scalar__type <- function(s){
    .Call(`_arrow_Scalar__type`, s)
}

Scalar__Equals <- function(lhs, rhs){
    .Call(`_arrow_Scalar__Equals`, lhs, rhs)
}

Scalar__ApproxEquals <- function(lhs, rhs){
    .Call(`_arrow_Scalar__ApproxEquals`, lhs, rhs)
}

schema_ <- function(fields){
    .Call(`_arrow_schema_`, fields)
}

Schema__ToString <- function(s){
    .Call(`_arrow_Schema__ToString`, s)
}

Schema__num_fields <- function(s){
    .Call(`_arrow_Schema__num_fields`, s)
}

Schema__field <- function(s, i){
    .Call(`_arrow_Schema__field`, s, i)
}

Schema__AddField <- function(s, i, field){
    .Call(`_arrow_Schema__AddField`, s, i, field)
}

Schema__SetField <- function(s, i, field){
    .Call(`_arrow_Schema__SetField`, s, i, field)
}

Schema__RemoveField <- function(s, i){
    .Call(`_arrow_Schema__RemoveField`, s, i)
}

Schema__GetFieldByName <- function(s, x){
    .Call(`_arrow_Schema__GetFieldByName`, s, x)
}

Schema__fields <- function(schema){
    .Call(`_arrow_Schema__fields`, schema)
}

Schema__field_names <- function(schema){
    .Call(`_arrow_Schema__field_names`, schema)
}

Schema__HasMetadata <- function(schema){
    .Call(`_arrow_Schema__HasMetadata`, schema)
}

Schema__metadata <- function(schema){
    .Call(`_arrow_Schema__metadata`, schema)
}

Schema__WithMetadata <- function(schema, metadata){
    .Call(`_arrow_Schema__WithMetadata`, schema, metadata)
}

Schema__serialize <- function(schema){
    .Call(`_arrow_Schema__serialize`, schema)
}

Schema__Equals <- function(schema, other, check_metadata){
    .Call(`_arrow_Schema__Equals`, schema, other, check_metadata)
}

arrow__UnifySchemas <- function(schemas){
    .Call(`_arrow_arrow__UnifySchemas`, schemas)
}

Table__num_columns <- function(x){
    .Call(`_arrow_Table__num_columns`, x)
}

Table__num_rows <- function(x){
    .Call(`_arrow_Table__num_rows`, x)
}

Table__schema <- function(x){
    .Call(`_arrow_Table__schema`, x)
}

Table__ReplaceSchemaMetadata <- function(x, metadata){
    .Call(`_arrow_Table__ReplaceSchemaMetadata`, x, metadata)
}

Table__column <- function(table, i){
    .Call(`_arrow_Table__column`, table, i)
}

Table__field <- function(table, i){
    .Call(`_arrow_Table__field`, table, i)
}

Table__columns <- function(table){
    .Call(`_arrow_Table__columns`, table)
}

Table__ColumnNames <- function(table){
    .Call(`_arrow_Table__ColumnNames`, table)
}

Table__RenameColumns <- function(table, names){
    .Call(`_arrow_Table__RenameColumns`, table, names)
}

Table__Slice1 <- function(table, offset){
    .Call(`_arrow_Table__Slice1`, table, offset)
}

Table__Slice2 <- function(table, offset, length){
    .Call(`_arrow_Table__Slice2`, table, offset, length)
}

Table__Equals <- function(lhs, rhs, check_metadata){
    .Call(`_arrow_Table__Equals`, lhs, rhs, check_metadata)
}

Table__Validate <- function(table){
    .Call(`_arrow_Table__Validate`, table)
}

Table__ValidateFull <- function(table){
    .Call(`_arrow_Table__ValidateFull`, table)
}

Table__GetColumnByName <- function(table, name){
    .Call(`_arrow_Table__GetColumnByName`, table, name)
}

Table__RemoveColumn <- function(table, i){
    .Call(`_arrow_Table__RemoveColumn`, table, i)
}

Table__AddColumn <- function(table, i, field, column){
    .Call(`_arrow_Table__AddColumn`, table, i, field, column)
}

Table__SetColumn <- function(table, i, field, column){
    .Call(`_arrow_Table__SetColumn`, table, i, field, column)
}

Table__SelectColumns <- function(table, indices){
    .Call(`_arrow_Table__SelectColumns`, table, indices)
}

all_record_batches <- function(lst){
    .Call(`_arrow_all_record_batches`, lst)
}

Table__from_record_batches <- function(batches, schema_sxp){
    .Call(`_arrow_Table__from_record_batches`, batches, schema_sxp)
}

GetCpuThreadPoolCapacity <- function(){
    .Call(`_arrow_GetCpuThreadPoolCapacity`)
}

SetCpuThreadPoolCapacity <- function(threads){
    invisible(.Call(`_arrow_SetCpuThreadPoolCapacity`, threads))
}

GetIOThreadPoolCapacity <- function(){
    .Call(`_arrow_GetIOThreadPoolCapacity`)
}

SetIOThreadPoolCapacity <- function(threads){
    invisible(.Call(`_arrow_SetIOThreadPoolCapacity`, threads))
}

Array__infer_type <- function(x){
    .Call(`_arrow_Array__infer_type`, x)
}



