# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.1
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _pytrexio
else:
    import _pytrexio

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class trexio_s(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    file_name = property(_pytrexio.trexio_s_file_name_get, _pytrexio.trexio_s_file_name_set)
    thread_lock = property(_pytrexio.trexio_s_thread_lock_get, _pytrexio.trexio_s_thread_lock_set)
    back_end = property(_pytrexio.trexio_s_back_end_get, _pytrexio.trexio_s_back_end_set)
    mode = property(_pytrexio.trexio_s_mode_get, _pytrexio.trexio_s_mode_set)
    one_based = property(_pytrexio.trexio_s_one_based_get, _pytrexio.trexio_s_one_based_set)
    state = property(_pytrexio.trexio_s_state_get, _pytrexio.trexio_s_state_set)
    version_major = property(_pytrexio.trexio_s_version_major_get, _pytrexio.trexio_s_version_major_set)
    version_minor = property(_pytrexio.trexio_s_version_minor_get, _pytrexio.trexio_s_version_minor_set)
    version_patch = property(_pytrexio.trexio_s_version_patch_get, _pytrexio.trexio_s_version_patch_set)
    version = property(_pytrexio.trexio_s_version_get, _pytrexio.trexio_s_version_set)

    def __init__(self):
        _pytrexio.trexio_s_swiginit(self, _pytrexio.new_trexio_s())
    __swig_destroy__ = _pytrexio.delete_trexio_s

# Register trexio_s in _pytrexio:
_pytrexio.trexio_s_swigregister(trexio_s)


def trexio_string_of_error(error: "trexio_exit_code const") -> "char const *":
    return _pytrexio.trexio_string_of_error(error)

def trexio_string_of_error_f(error: "trexio_exit_code const", result: "char [128]") -> "void":
    return _pytrexio.trexio_string_of_error_f(error, result)
TREXIO_DELIM = _pytrexio.TREXIO_DELIM

def trexio_has_backend(back_end: "back_end_t") -> "bool":
    return _pytrexio.trexio_has_backend(back_end)

def trexio_has_back_end(back_end: "back_end_t") -> "bool":
    return _pytrexio.trexio_has_back_end(back_end)

def trexio_open(file_name: "char const *", mode: "char const", back_end: "back_end_t const") -> "trexio_exit_code *const":
    return _pytrexio.trexio_open(file_name, mode, back_end)

def trexio_set_one_based(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_set_one_based(file)

def trexio_close(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_close(file)

def trexio_flush(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_flush(file)

def trexio_inquire(file_name: "char const *") -> "trexio_exit_code":
    return _pytrexio.trexio_inquire(file_name)

def trexio_cp(source_file_name: "char const *", dest_file_name: "char const *") -> "trexio_exit_code":
    return _pytrexio.trexio_cp(source_file_name, dest_file_name)

def trexio_set_state(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_set_state(file, num)

def trexio_get_state(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_get_state(file)

def trexio_info() -> "trexio_exit_code":
    return _pytrexio.trexio_info()

def trexio_mark_safety(file: "trexio_s", safety_flag: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_mark_safety(file, safety_flag)
TREXIO_ORBITAL_SHIFT = _pytrexio.TREXIO_ORBITAL_SHIFT
TREXIO_INT_SIZE = _pytrexio.TREXIO_INT_SIZE

def trexio_to_orbital_list(N_int: "int32_t const", d1: "bitfield_t const *", list: "int32_t *const", occupied_num: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_to_orbital_list(N_int, d1, list, occupied_num)

def trexio_to_orbital_list_up_dn(N_int: "int32_t const", d1: "bitfield_t const *", list_up: "int32_t *const", list_dn: "int32_t *const", occ_num_up: "int32_t *const", occ_num_dn: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_to_orbital_list_up_dn(N_int, d1, list_up, list_dn, occ_num_up, occ_num_dn)

def trexio_safe_to_orbital_list(N_int: "int32_t const", dset_in: "bitfield_t const *", dset_out: "int32_t *const") -> "int64_t const, int32_t *const":
    return _pytrexio.trexio_safe_to_orbital_list(N_int, dset_in, dset_out)

def trexio_safe_to_orbital_list_up_dn(N_int: "int32_t const", dset_in: "bitfield_t const *", dset_up_out: "int32_t *const", dset_dn_out: "int32_t *const") -> "int64_t const, int64_t const, int32_t *const, int32_t *const":
    return _pytrexio.trexio_safe_to_orbital_list_up_dn(N_int, dset_in, dset_up_out, dset_dn_out)

def trexio_to_bitfield_list(orb_list: "int32_t const *", bit_list: "bitfield_t *const") -> "int32_t const":
    return _pytrexio.trexio_to_bitfield_list(orb_list, bit_list)
TREXIO_PACKAGE_VERSION = _pytrexio.TREXIO_PACKAGE_VERSION
TREXIO_VERSION_MAJOR = _pytrexio.TREXIO_VERSION_MAJOR
TREXIO_VERSION_MINOR = _pytrexio.TREXIO_VERSION_MINOR
TREXIO_VERSION_PATCH = _pytrexio.TREXIO_VERSION_PATCH
TREXIO_GIT_HASH = _pytrexio.TREXIO_GIT_HASH

def trexio_delete_metadata(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_metadata(file)

def trexio_delete_nucleus(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_nucleus(file)

def trexio_delete_cell(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_cell(file)

def trexio_delete_pbc(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_pbc(file)

def trexio_delete_electron(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_electron(file)

def trexio_delete_state(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_state(file)

def trexio_delete_basis(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_basis(file)

def trexio_delete_ecp(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_ecp(file)

def trexio_delete_grid(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_grid(file)

def trexio_delete_ao(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_ao(file)

def trexio_delete_ao_1e_int(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_ao_1e_int(file)

def trexio_delete_ao_2e_int(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_ao_2e_int(file)

def trexio_delete_mo(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_mo(file)

def trexio_delete_mo_1e_int(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_mo_1e_int(file)

def trexio_delete_mo_2e_int(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_mo_2e_int(file)

def trexio_delete_determinant(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_determinant(file)

def trexio_delete_csf(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_csf(file)

def trexio_delete_amplitude(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_amplitude(file)

def trexio_delete_rdm(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_rdm(file)

def trexio_delete_jastrow(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_jastrow(file)

def trexio_delete_qmc(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_delete_qmc(file)

def trexio_has_metadata_code_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_metadata_code_num(file)

def trexio_read_metadata_code_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_metadata_code_num(file)

def trexio_write_metadata_code_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_code_num(file, num)

def trexio_read_metadata_code_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_metadata_code_num_32(file)

def trexio_write_metadata_code_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_code_num_32(file, num)

def trexio_read_metadata_code_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_metadata_code_num_64(file)

def trexio_write_metadata_code_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_code_num_64(file, num)

def trexio_has_metadata_author_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_metadata_author_num(file)

def trexio_read_metadata_author_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_metadata_author_num(file)

def trexio_write_metadata_author_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_author_num(file, num)

def trexio_read_metadata_author_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_metadata_author_num_32(file)

def trexio_write_metadata_author_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_author_num_32(file, num)

def trexio_read_metadata_author_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_metadata_author_num_64(file)

def trexio_write_metadata_author_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_author_num_64(file, num)

def trexio_has_metadata_unsafe(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_metadata_unsafe(file)

def trexio_read_metadata_unsafe(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_metadata_unsafe(file)

def trexio_write_metadata_unsafe(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_unsafe(file, num)

def trexio_read_metadata_unsafe_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_metadata_unsafe_32(file)

def trexio_write_metadata_unsafe_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_unsafe_32(file, num)

def trexio_read_metadata_unsafe_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_metadata_unsafe_64(file)

def trexio_write_metadata_unsafe_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_unsafe_64(file, num)

def trexio_has_nucleus_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_nucleus_num(file)

def trexio_read_nucleus_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_nucleus_num(file)

def trexio_write_nucleus_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_num(file, num)

def trexio_read_nucleus_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_nucleus_num_32(file)

def trexio_write_nucleus_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_num_32(file, num)

def trexio_read_nucleus_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_nucleus_num_64(file)

def trexio_write_nucleus_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_num_64(file, num)

def trexio_has_nucleus_repulsion(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_nucleus_repulsion(file)

def trexio_read_nucleus_repulsion(file: "trexio_s") -> "double *const":
    return _pytrexio.trexio_read_nucleus_repulsion(file)

def trexio_write_nucleus_repulsion(file: "trexio_s", num: "double const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_repulsion(file, num)

def trexio_read_nucleus_repulsion_32(file: "trexio_s") -> "float *const":
    return _pytrexio.trexio_read_nucleus_repulsion_32(file)

def trexio_write_nucleus_repulsion_32(file: "trexio_s", num: "float const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_repulsion_32(file, num)

def trexio_read_nucleus_repulsion_64(file: "trexio_s") -> "double *const":
    return _pytrexio.trexio_read_nucleus_repulsion_64(file)

def trexio_write_nucleus_repulsion_64(file: "trexio_s", num: "double const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_repulsion_64(file, num)

def trexio_has_cell_two_pi(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_cell_two_pi(file)

def trexio_read_cell_two_pi(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_cell_two_pi(file)

def trexio_write_cell_two_pi(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_two_pi(file, num)

def trexio_read_cell_two_pi_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_cell_two_pi_32(file)

def trexio_write_cell_two_pi_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_two_pi_32(file, num)

def trexio_read_cell_two_pi_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_cell_two_pi_64(file)

def trexio_write_cell_two_pi_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_two_pi_64(file, num)

def trexio_has_pbc_periodic(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_pbc_periodic(file)

def trexio_read_pbc_periodic(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_pbc_periodic(file)

def trexio_write_pbc_periodic(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_pbc_periodic(file, num)

def trexio_read_pbc_periodic_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_pbc_periodic_32(file)

def trexio_write_pbc_periodic_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_pbc_periodic_32(file, num)

def trexio_read_pbc_periodic_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_pbc_periodic_64(file)

def trexio_write_pbc_periodic_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_pbc_periodic_64(file, num)

def trexio_has_electron_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_electron_num(file)

def trexio_read_electron_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_electron_num(file)

def trexio_write_electron_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_electron_num(file, num)

def trexio_read_electron_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_electron_num_32(file)

def trexio_write_electron_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_electron_num_32(file, num)

def trexio_read_electron_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_electron_num_64(file)

def trexio_write_electron_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_electron_num_64(file, num)

def trexio_has_electron_up_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_electron_up_num(file)

def trexio_read_electron_up_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_electron_up_num(file)

def trexio_write_electron_up_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_electron_up_num(file, num)

def trexio_read_electron_up_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_electron_up_num_32(file)

def trexio_write_electron_up_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_electron_up_num_32(file, num)

def trexio_read_electron_up_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_electron_up_num_64(file)

def trexio_write_electron_up_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_electron_up_num_64(file, num)

def trexio_has_electron_dn_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_electron_dn_num(file)

def trexio_read_electron_dn_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_electron_dn_num(file)

def trexio_write_electron_dn_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_electron_dn_num(file, num)

def trexio_read_electron_dn_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_electron_dn_num_32(file)

def trexio_write_electron_dn_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_electron_dn_num_32(file, num)

def trexio_read_electron_dn_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_electron_dn_num_64(file)

def trexio_write_electron_dn_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_electron_dn_num_64(file, num)

def trexio_has_state_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_state_num(file)

def trexio_read_state_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_state_num(file)

def trexio_write_state_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_state_num(file, num)

def trexio_read_state_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_state_num_32(file)

def trexio_write_state_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_state_num_32(file, num)

def trexio_read_state_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_state_num_64(file)

def trexio_write_state_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_state_num_64(file, num)

def trexio_has_state_id(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_state_id(file)

def trexio_read_state_id(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_state_id(file)

def trexio_write_state_id(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_state_id(file, num)

def trexio_read_state_id_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_state_id_32(file)

def trexio_write_state_id_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_state_id_32(file, num)

def trexio_read_state_id_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_state_id_64(file)

def trexio_write_state_id_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_state_id_64(file, num)

def trexio_has_basis_prim_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_prim_num(file)

def trexio_read_basis_prim_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_basis_prim_num(file)

def trexio_write_basis_prim_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_prim_num(file, num)

def trexio_read_basis_prim_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_basis_prim_num_32(file)

def trexio_write_basis_prim_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_prim_num_32(file, num)

def trexio_read_basis_prim_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_basis_prim_num_64(file)

def trexio_write_basis_prim_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_prim_num_64(file, num)

def trexio_has_basis_shell_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_shell_num(file)

def trexio_read_basis_shell_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_basis_shell_num(file)

def trexio_write_basis_shell_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_num(file, num)

def trexio_read_basis_shell_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_basis_shell_num_32(file)

def trexio_write_basis_shell_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_num_32(file, num)

def trexio_read_basis_shell_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_basis_shell_num_64(file)

def trexio_write_basis_shell_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_num_64(file, num)

def trexio_has_basis_e_cut(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_e_cut(file)

def trexio_read_basis_e_cut(file: "trexio_s") -> "double *const":
    return _pytrexio.trexio_read_basis_e_cut(file)

def trexio_write_basis_e_cut(file: "trexio_s", num: "double const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_e_cut(file, num)

def trexio_read_basis_e_cut_32(file: "trexio_s") -> "float *const":
    return _pytrexio.trexio_read_basis_e_cut_32(file)

def trexio_write_basis_e_cut_32(file: "trexio_s", num: "float const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_e_cut_32(file, num)

def trexio_read_basis_e_cut_64(file: "trexio_s") -> "double *const":
    return _pytrexio.trexio_read_basis_e_cut_64(file)

def trexio_write_basis_e_cut_64(file: "trexio_s", num: "double const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_e_cut_64(file, num)

def trexio_has_ecp_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ecp_num(file)

def trexio_read_ecp_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_ecp_num(file)

def trexio_write_ecp_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_num(file, num)

def trexio_read_ecp_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_ecp_num_32(file)

def trexio_write_ecp_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_num_32(file, num)

def trexio_read_ecp_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_ecp_num_64(file)

def trexio_write_ecp_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_num_64(file, num)

def trexio_has_grid_rad_precision(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_rad_precision(file)

def trexio_read_grid_rad_precision(file: "trexio_s") -> "double *const":
    return _pytrexio.trexio_read_grid_rad_precision(file)

def trexio_write_grid_rad_precision(file: "trexio_s", num: "double const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_precision(file, num)

def trexio_read_grid_rad_precision_32(file: "trexio_s") -> "float *const":
    return _pytrexio.trexio_read_grid_rad_precision_32(file)

def trexio_write_grid_rad_precision_32(file: "trexio_s", num: "float const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_precision_32(file, num)

def trexio_read_grid_rad_precision_64(file: "trexio_s") -> "double *const":
    return _pytrexio.trexio_read_grid_rad_precision_64(file)

def trexio_write_grid_rad_precision_64(file: "trexio_s", num: "double const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_precision_64(file, num)

def trexio_has_grid_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_num(file)

def trexio_read_grid_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_grid_num(file)

def trexio_write_grid_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_num(file, num)

def trexio_read_grid_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_grid_num_32(file)

def trexio_write_grid_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_num_32(file, num)

def trexio_read_grid_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_grid_num_64(file)

def trexio_write_grid_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_num_64(file, num)

def trexio_has_grid_max_ang_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_max_ang_num(file)

def trexio_read_grid_max_ang_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_grid_max_ang_num(file)

def trexio_write_grid_max_ang_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_max_ang_num(file, num)

def trexio_read_grid_max_ang_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_grid_max_ang_num_32(file)

def trexio_write_grid_max_ang_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_max_ang_num_32(file, num)

def trexio_read_grid_max_ang_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_grid_max_ang_num_64(file)

def trexio_write_grid_max_ang_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_max_ang_num_64(file, num)

def trexio_has_grid_min_ang_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_min_ang_num(file)

def trexio_read_grid_min_ang_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_grid_min_ang_num(file)

def trexio_write_grid_min_ang_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_min_ang_num(file, num)

def trexio_read_grid_min_ang_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_grid_min_ang_num_32(file)

def trexio_write_grid_min_ang_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_min_ang_num_32(file, num)

def trexio_read_grid_min_ang_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_grid_min_ang_num_64(file)

def trexio_write_grid_min_ang_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_min_ang_num_64(file, num)

def trexio_has_grid_ang_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_ang_num(file)

def trexio_read_grid_ang_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_grid_ang_num(file)

def trexio_write_grid_ang_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_ang_num(file, num)

def trexio_read_grid_ang_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_grid_ang_num_32(file)

def trexio_write_grid_ang_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_ang_num_32(file, num)

def trexio_read_grid_ang_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_grid_ang_num_64(file)

def trexio_write_grid_ang_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_ang_num_64(file, num)

def trexio_has_grid_rad_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_rad_num(file)

def trexio_read_grid_rad_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_grid_rad_num(file)

def trexio_write_grid_rad_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_num(file, num)

def trexio_read_grid_rad_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_grid_rad_num_32(file)

def trexio_write_grid_rad_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_num_32(file, num)

def trexio_read_grid_rad_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_grid_rad_num_64(file)

def trexio_write_grid_rad_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_num_64(file, num)

def trexio_has_ao_cartesian(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_cartesian(file)

def trexio_read_ao_cartesian(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_ao_cartesian(file)

def trexio_write_ao_cartesian(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_cartesian(file, num)

def trexio_read_ao_cartesian_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_ao_cartesian_32(file)

def trexio_write_ao_cartesian_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_cartesian_32(file, num)

def trexio_read_ao_cartesian_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_ao_cartesian_64(file)

def trexio_write_ao_cartesian_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_cartesian_64(file, num)

def trexio_has_ao_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_num(file)

def trexio_read_ao_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_ao_num(file)

def trexio_write_ao_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_num(file, num)

def trexio_read_ao_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_ao_num_32(file)

def trexio_write_ao_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_num_32(file, num)

def trexio_read_ao_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_ao_num_64(file)

def trexio_write_ao_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_num_64(file, num)

def trexio_has_ao_2e_int_eri_cholesky_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_2e_int_eri_cholesky_num(file)

def trexio_read_ao_2e_int_eri_cholesky_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_ao_2e_int_eri_cholesky_num(file)

def trexio_write_ao_2e_int_eri_cholesky_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_2e_int_eri_cholesky_num(file, num)

def trexio_read_ao_2e_int_eri_cholesky_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_ao_2e_int_eri_cholesky_num_32(file)

def trexio_write_ao_2e_int_eri_cholesky_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_2e_int_eri_cholesky_num_32(file, num)

def trexio_read_ao_2e_int_eri_cholesky_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_ao_2e_int_eri_cholesky_num_64(file)

def trexio_write_ao_2e_int_eri_cholesky_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_2e_int_eri_cholesky_num_64(file, num)

def trexio_has_ao_2e_int_eri_lr_cholesky_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_2e_int_eri_lr_cholesky_num(file)

def trexio_read_ao_2e_int_eri_lr_cholesky_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_ao_2e_int_eri_lr_cholesky_num(file)

def trexio_write_ao_2e_int_eri_lr_cholesky_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_2e_int_eri_lr_cholesky_num(file, num)

def trexio_read_ao_2e_int_eri_lr_cholesky_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_ao_2e_int_eri_lr_cholesky_num_32(file)

def trexio_write_ao_2e_int_eri_lr_cholesky_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_2e_int_eri_lr_cholesky_num_32(file, num)

def trexio_read_ao_2e_int_eri_lr_cholesky_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_ao_2e_int_eri_lr_cholesky_num_64(file)

def trexio_write_ao_2e_int_eri_lr_cholesky_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_2e_int_eri_lr_cholesky_num_64(file, num)

def trexio_has_mo_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_num(file)

def trexio_read_mo_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_mo_num(file)

def trexio_write_mo_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_num(file, num)

def trexio_read_mo_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_mo_num_32(file)

def trexio_write_mo_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_num_32(file, num)

def trexio_read_mo_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_mo_num_64(file)

def trexio_write_mo_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_num_64(file, num)

def trexio_has_mo_2e_int_eri_cholesky_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_2e_int_eri_cholesky_num(file)

def trexio_read_mo_2e_int_eri_cholesky_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_mo_2e_int_eri_cholesky_num(file)

def trexio_write_mo_2e_int_eri_cholesky_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_2e_int_eri_cholesky_num(file, num)

def trexio_read_mo_2e_int_eri_cholesky_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_mo_2e_int_eri_cholesky_num_32(file)

def trexio_write_mo_2e_int_eri_cholesky_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_2e_int_eri_cholesky_num_32(file, num)

def trexio_read_mo_2e_int_eri_cholesky_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_mo_2e_int_eri_cholesky_num_64(file)

def trexio_write_mo_2e_int_eri_cholesky_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_2e_int_eri_cholesky_num_64(file, num)

def trexio_has_mo_2e_int_eri_lr_cholesky_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_2e_int_eri_lr_cholesky_num(file)

def trexio_read_mo_2e_int_eri_lr_cholesky_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_mo_2e_int_eri_lr_cholesky_num(file)

def trexio_write_mo_2e_int_eri_lr_cholesky_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_2e_int_eri_lr_cholesky_num(file, num)

def trexio_read_mo_2e_int_eri_lr_cholesky_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_mo_2e_int_eri_lr_cholesky_num_32(file)

def trexio_write_mo_2e_int_eri_lr_cholesky_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_2e_int_eri_lr_cholesky_num_32(file, num)

def trexio_read_mo_2e_int_eri_lr_cholesky_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_mo_2e_int_eri_lr_cholesky_num_64(file)

def trexio_write_mo_2e_int_eri_lr_cholesky_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_2e_int_eri_lr_cholesky_num_64(file, num)

def trexio_has_determinant_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_determinant_num(file)

def trexio_read_determinant_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_determinant_num(file)

def trexio_read_determinant_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_determinant_num_32(file)

def trexio_read_determinant_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_determinant_num_64(file)

def trexio_has_csf_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_csf_num(file)

def trexio_read_csf_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_csf_num(file)

def trexio_read_csf_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_csf_num_32(file)

def trexio_read_csf_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_csf_num_64(file)

def trexio_has_rdm_2e_cholesky_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e_cholesky_num(file)

def trexio_read_rdm_2e_cholesky_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_rdm_2e_cholesky_num(file)

def trexio_write_rdm_2e_cholesky_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_cholesky_num(file, num)

def trexio_read_rdm_2e_cholesky_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_rdm_2e_cholesky_num_32(file)

def trexio_write_rdm_2e_cholesky_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_cholesky_num_32(file, num)

def trexio_read_rdm_2e_cholesky_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_cholesky_num_64(file)

def trexio_write_rdm_2e_cholesky_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_cholesky_num_64(file, num)

def trexio_has_rdm_2e_upup_cholesky_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e_upup_cholesky_num(file)

def trexio_read_rdm_2e_upup_cholesky_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_rdm_2e_upup_cholesky_num(file)

def trexio_write_rdm_2e_upup_cholesky_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_upup_cholesky_num(file, num)

def trexio_read_rdm_2e_upup_cholesky_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_rdm_2e_upup_cholesky_num_32(file)

def trexio_write_rdm_2e_upup_cholesky_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_upup_cholesky_num_32(file, num)

def trexio_read_rdm_2e_upup_cholesky_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_upup_cholesky_num_64(file)

def trexio_write_rdm_2e_upup_cholesky_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_upup_cholesky_num_64(file, num)

def trexio_has_rdm_2e_dndn_cholesky_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e_dndn_cholesky_num(file)

def trexio_read_rdm_2e_dndn_cholesky_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_rdm_2e_dndn_cholesky_num(file)

def trexio_write_rdm_2e_dndn_cholesky_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_dndn_cholesky_num(file, num)

def trexio_read_rdm_2e_dndn_cholesky_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_rdm_2e_dndn_cholesky_num_32(file)

def trexio_write_rdm_2e_dndn_cholesky_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_dndn_cholesky_num_32(file, num)

def trexio_read_rdm_2e_dndn_cholesky_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_dndn_cholesky_num_64(file)

def trexio_write_rdm_2e_dndn_cholesky_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_dndn_cholesky_num_64(file, num)

def trexio_has_rdm_2e_updn_cholesky_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e_updn_cholesky_num(file)

def trexio_read_rdm_2e_updn_cholesky_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_rdm_2e_updn_cholesky_num(file)

def trexio_write_rdm_2e_updn_cholesky_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_updn_cholesky_num(file, num)

def trexio_read_rdm_2e_updn_cholesky_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_rdm_2e_updn_cholesky_num_32(file)

def trexio_write_rdm_2e_updn_cholesky_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_updn_cholesky_num_32(file, num)

def trexio_read_rdm_2e_updn_cholesky_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_updn_cholesky_num_64(file)

def trexio_write_rdm_2e_updn_cholesky_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_updn_cholesky_num_64(file, num)

def trexio_has_jastrow_en_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow_en_num(file)

def trexio_read_jastrow_en_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_jastrow_en_num(file)

def trexio_write_jastrow_en_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en_num(file, num)

def trexio_read_jastrow_en_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_jastrow_en_num_32(file)

def trexio_write_jastrow_en_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en_num_32(file, num)

def trexio_read_jastrow_en_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_jastrow_en_num_64(file)

def trexio_write_jastrow_en_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en_num_64(file, num)

def trexio_has_jastrow_ee_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow_ee_num(file)

def trexio_read_jastrow_ee_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_jastrow_ee_num(file)

def trexio_write_jastrow_ee_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_ee_num(file, num)

def trexio_read_jastrow_ee_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_jastrow_ee_num_32(file)

def trexio_write_jastrow_ee_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_ee_num_32(file, num)

def trexio_read_jastrow_ee_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_jastrow_ee_num_64(file)

def trexio_write_jastrow_ee_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_ee_num_64(file, num)

def trexio_has_jastrow_een_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow_een_num(file)

def trexio_read_jastrow_een_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_jastrow_een_num(file)

def trexio_write_jastrow_een_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_een_num(file, num)

def trexio_read_jastrow_een_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_jastrow_een_num_32(file)

def trexio_write_jastrow_een_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_een_num_32(file, num)

def trexio_read_jastrow_een_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_jastrow_een_num_64(file)

def trexio_write_jastrow_een_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_een_num_64(file, num)

def trexio_has_jastrow_ee_scaling(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow_ee_scaling(file)

def trexio_read_jastrow_ee_scaling(file: "trexio_s") -> "double *const":
    return _pytrexio.trexio_read_jastrow_ee_scaling(file)

def trexio_write_jastrow_ee_scaling(file: "trexio_s", num: "double const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_ee_scaling(file, num)

def trexio_read_jastrow_ee_scaling_32(file: "trexio_s") -> "float *const":
    return _pytrexio.trexio_read_jastrow_ee_scaling_32(file)

def trexio_write_jastrow_ee_scaling_32(file: "trexio_s", num: "float const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_ee_scaling_32(file, num)

def trexio_read_jastrow_ee_scaling_64(file: "trexio_s") -> "double *const":
    return _pytrexio.trexio_read_jastrow_ee_scaling_64(file)

def trexio_write_jastrow_ee_scaling_64(file: "trexio_s", num: "double const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_ee_scaling_64(file, num)

def trexio_has_qmc_num(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_qmc_num(file)

def trexio_read_qmc_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_qmc_num(file)

def trexio_write_qmc_num(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_num(file, num)

def trexio_read_qmc_num_32(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_read_qmc_num_32(file)

def trexio_write_qmc_num_32(file: "trexio_s", num: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_num_32(file, num)

def trexio_read_qmc_num_64(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_qmc_num_64(file)

def trexio_write_qmc_num_64(file: "trexio_s", num: "int64_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_num_64(file, num)

def trexio_has_metadata_package_version(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_metadata_package_version(file)

def trexio_read_metadata_package_version(file: "trexio_s", str_out: "char *const") -> "int32_t const":
    return _pytrexio.trexio_read_metadata_package_version(file, str_out)

def trexio_write_metadata_package_version(file: "trexio_s", str: "char const *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_package_version(file, str, max_str_len)

def trexio_has_metadata_description(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_metadata_description(file)

def trexio_read_metadata_description(file: "trexio_s", str_out: "char *const") -> "int32_t const":
    return _pytrexio.trexio_read_metadata_description(file, str_out)

def trexio_write_metadata_description(file: "trexio_s", str: "char const *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_description(file, str, max_str_len)

def trexio_has_nucleus_point_group(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_nucleus_point_group(file)

def trexio_read_nucleus_point_group(file: "trexio_s", str_out: "char *const") -> "int32_t const":
    return _pytrexio.trexio_read_nucleus_point_group(file, str_out)

def trexio_write_nucleus_point_group(file: "trexio_s", str: "char const *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_point_group(file, str, max_str_len)

def trexio_has_state_current_label(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_state_current_label(file)

def trexio_read_state_current_label(file: "trexio_s", str_out: "char *const") -> "int32_t const":
    return _pytrexio.trexio_read_state_current_label(file, str_out)

def trexio_write_state_current_label(file: "trexio_s", str: "char const *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_state_current_label(file, str, max_str_len)

def trexio_has_basis_type(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_type(file)

def trexio_read_basis_type(file: "trexio_s", str_out: "char *const") -> "int32_t const":
    return _pytrexio.trexio_read_basis_type(file, str_out)

def trexio_write_basis_type(file: "trexio_s", str: "char const *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_type(file, str, max_str_len)

def trexio_has_grid_description(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_description(file)

def trexio_read_grid_description(file: "trexio_s", str_out: "char *const") -> "int32_t const":
    return _pytrexio.trexio_read_grid_description(file, str_out)

def trexio_write_grid_description(file: "trexio_s", str: "char const *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_description(file, str, max_str_len)

def trexio_has_mo_type(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_type(file)

def trexio_read_mo_type(file: "trexio_s", str_out: "char *const") -> "int32_t const":
    return _pytrexio.trexio_read_mo_type(file, str_out)

def trexio_write_mo_type(file: "trexio_s", str: "char const *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_type(file, str, max_str_len)

def trexio_has_jastrow_type(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow_type(file)

def trexio_read_jastrow_type(file: "trexio_s", str_out: "char *const") -> "int32_t const":
    return _pytrexio.trexio_read_jastrow_type(file, str_out)

def trexio_write_jastrow_type(file: "trexio_s", str: "char const *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_type(file, str, max_str_len)

def trexio_has_determinant_coefficient(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_determinant_coefficient(file)

def trexio_read_determinant_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", dset: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_determinant_coefficient(file, offset_file, buffer_size, dset)

def trexio_read_safe_determinant_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", dset_out: "double *const") -> "int64_t *const, int64_t const":
    return _pytrexio.trexio_read_safe_determinant_coefficient(file, offset_file, buffer_size_read, dset_out)

def trexio_write_determinant_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", dset: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_determinant_coefficient(file, offset_file, buffer_size, dset)

def trexio_write_safe_determinant_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_determinant_coefficient(file, offset_file, buffer_size, dset_in)

def trexio_read_determinant_coefficient_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_determinant_coefficient_size(file)

def trexio_has_csf_coefficient(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_csf_coefficient(file)

def trexio_read_csf_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", dset: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_csf_coefficient(file, offset_file, buffer_size, dset)

def trexio_read_safe_csf_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", dset_out: "double *const") -> "int64_t *const, int64_t const":
    return _pytrexio.trexio_read_safe_csf_coefficient(file, offset_file, buffer_size_read, dset_out)

def trexio_write_csf_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", dset: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_csf_coefficient(file, offset_file, buffer_size, dset)

def trexio_write_safe_csf_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_csf_coefficient(file, offset_file, buffer_size, dset_in)

def trexio_read_csf_coefficient_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_csf_coefficient_size(file)

def trexio_has_nucleus_charge(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_nucleus_charge(file)

def trexio_read_nucleus_charge(file: "trexio_s", nucleus_charge: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_nucleus_charge(file, nucleus_charge)

def trexio_write_nucleus_charge(file: "trexio_s", nucleus_charge: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_charge(file, nucleus_charge)

def trexio_read_nucleus_charge_32(file: "trexio_s", nucleus_charge: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_nucleus_charge_32(file, nucleus_charge)

def trexio_write_nucleus_charge_32(file: "trexio_s", nucleus_charge: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_charge_32(file, nucleus_charge)

def trexio_read_nucleus_charge_64(file: "trexio_s", nucleus_charge: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_nucleus_charge_64(file, nucleus_charge)

def trexio_write_nucleus_charge_64(file: "trexio_s", nucleus_charge: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_charge_64(file, nucleus_charge)

def trexio_read_safe_nucleus_charge(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_nucleus_charge(file, dset_out)

def trexio_write_safe_nucleus_charge(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_nucleus_charge(file, dset_in)

def trexio_read_safe_nucleus_charge_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_nucleus_charge_32(file, dset_out)

def trexio_write_safe_nucleus_charge_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_nucleus_charge_32(file, dset_in)

def trexio_read_safe_nucleus_charge_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_nucleus_charge_64(file, dset_out)

def trexio_write_safe_nucleus_charge_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_nucleus_charge_64(file, dset_in)

def trexio_has_nucleus_coord(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_nucleus_coord(file)

def trexio_read_nucleus_coord(file: "trexio_s", nucleus_coord: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_nucleus_coord(file, nucleus_coord)

def trexio_write_nucleus_coord(file: "trexio_s", nucleus_coord: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_coord(file, nucleus_coord)

def trexio_read_nucleus_coord_32(file: "trexio_s", nucleus_coord: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_nucleus_coord_32(file, nucleus_coord)

def trexio_write_nucleus_coord_32(file: "trexio_s", nucleus_coord: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_coord_32(file, nucleus_coord)

def trexio_read_nucleus_coord_64(file: "trexio_s", nucleus_coord: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_nucleus_coord_64(file, nucleus_coord)

def trexio_write_nucleus_coord_64(file: "trexio_s", nucleus_coord: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_coord_64(file, nucleus_coord)

def trexio_read_safe_nucleus_coord(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_nucleus_coord(file, dset_out)

def trexio_write_safe_nucleus_coord(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_nucleus_coord(file, dset_in)

def trexio_read_safe_nucleus_coord_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_nucleus_coord_32(file, dset_out)

def trexio_write_safe_nucleus_coord_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_nucleus_coord_32(file, dset_in)

def trexio_read_safe_nucleus_coord_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_nucleus_coord_64(file, dset_out)

def trexio_write_safe_nucleus_coord_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_nucleus_coord_64(file, dset_in)

def trexio_has_cell_a(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_cell_a(file)

def trexio_read_cell_a(file: "trexio_s", cell_a: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_a(file, cell_a)

def trexio_write_cell_a(file: "trexio_s", cell_a: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_a(file, cell_a)

def trexio_read_cell_a_32(file: "trexio_s", cell_a: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_a_32(file, cell_a)

def trexio_write_cell_a_32(file: "trexio_s", cell_a: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_a_32(file, cell_a)

def trexio_read_cell_a_64(file: "trexio_s", cell_a: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_a_64(file, cell_a)

def trexio_write_cell_a_64(file: "trexio_s", cell_a: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_a_64(file, cell_a)

def trexio_read_safe_cell_a(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_a(file, dset_out)

def trexio_write_safe_cell_a(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_a(file, dset_in)

def trexio_read_safe_cell_a_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_a_32(file, dset_out)

def trexio_write_safe_cell_a_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_a_32(file, dset_in)

def trexio_read_safe_cell_a_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_a_64(file, dset_out)

def trexio_write_safe_cell_a_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_a_64(file, dset_in)

def trexio_has_cell_b(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_cell_b(file)

def trexio_read_cell_b(file: "trexio_s", cell_b: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_b(file, cell_b)

def trexio_write_cell_b(file: "trexio_s", cell_b: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_b(file, cell_b)

def trexio_read_cell_b_32(file: "trexio_s", cell_b: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_b_32(file, cell_b)

def trexio_write_cell_b_32(file: "trexio_s", cell_b: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_b_32(file, cell_b)

def trexio_read_cell_b_64(file: "trexio_s", cell_b: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_b_64(file, cell_b)

def trexio_write_cell_b_64(file: "trexio_s", cell_b: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_b_64(file, cell_b)

def trexio_read_safe_cell_b(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_b(file, dset_out)

def trexio_write_safe_cell_b(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_b(file, dset_in)

def trexio_read_safe_cell_b_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_b_32(file, dset_out)

def trexio_write_safe_cell_b_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_b_32(file, dset_in)

def trexio_read_safe_cell_b_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_b_64(file, dset_out)

def trexio_write_safe_cell_b_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_b_64(file, dset_in)

def trexio_has_cell_c(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_cell_c(file)

def trexio_read_cell_c(file: "trexio_s", cell_c: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_c(file, cell_c)

def trexio_write_cell_c(file: "trexio_s", cell_c: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_c(file, cell_c)

def trexio_read_cell_c_32(file: "trexio_s", cell_c: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_c_32(file, cell_c)

def trexio_write_cell_c_32(file: "trexio_s", cell_c: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_c_32(file, cell_c)

def trexio_read_cell_c_64(file: "trexio_s", cell_c: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_c_64(file, cell_c)

def trexio_write_cell_c_64(file: "trexio_s", cell_c: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_c_64(file, cell_c)

def trexio_read_safe_cell_c(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_c(file, dset_out)

def trexio_write_safe_cell_c(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_c(file, dset_in)

def trexio_read_safe_cell_c_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_c_32(file, dset_out)

def trexio_write_safe_cell_c_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_c_32(file, dset_in)

def trexio_read_safe_cell_c_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_c_64(file, dset_out)

def trexio_write_safe_cell_c_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_c_64(file, dset_in)

def trexio_has_cell_G_a(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_cell_G_a(file)

def trexio_read_cell_G_a(file: "trexio_s", cell_G_a: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_G_a(file, cell_G_a)

def trexio_write_cell_G_a(file: "trexio_s", cell_G_a: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_G_a(file, cell_G_a)

def trexio_read_cell_G_a_32(file: "trexio_s", cell_G_a: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_G_a_32(file, cell_G_a)

def trexio_write_cell_G_a_32(file: "trexio_s", cell_G_a: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_G_a_32(file, cell_G_a)

def trexio_read_cell_G_a_64(file: "trexio_s", cell_G_a: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_G_a_64(file, cell_G_a)

def trexio_write_cell_G_a_64(file: "trexio_s", cell_G_a: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_G_a_64(file, cell_G_a)

def trexio_read_safe_cell_G_a(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_G_a(file, dset_out)

def trexio_write_safe_cell_G_a(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_G_a(file, dset_in)

def trexio_read_safe_cell_G_a_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_G_a_32(file, dset_out)

def trexio_write_safe_cell_G_a_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_G_a_32(file, dset_in)

def trexio_read_safe_cell_G_a_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_G_a_64(file, dset_out)

def trexio_write_safe_cell_G_a_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_G_a_64(file, dset_in)

def trexio_has_cell_G_b(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_cell_G_b(file)

def trexio_read_cell_G_b(file: "trexio_s", cell_G_b: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_G_b(file, cell_G_b)

def trexio_write_cell_G_b(file: "trexio_s", cell_G_b: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_G_b(file, cell_G_b)

def trexio_read_cell_G_b_32(file: "trexio_s", cell_G_b: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_G_b_32(file, cell_G_b)

def trexio_write_cell_G_b_32(file: "trexio_s", cell_G_b: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_G_b_32(file, cell_G_b)

def trexio_read_cell_G_b_64(file: "trexio_s", cell_G_b: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_G_b_64(file, cell_G_b)

def trexio_write_cell_G_b_64(file: "trexio_s", cell_G_b: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_G_b_64(file, cell_G_b)

def trexio_read_safe_cell_G_b(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_G_b(file, dset_out)

def trexio_write_safe_cell_G_b(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_G_b(file, dset_in)

def trexio_read_safe_cell_G_b_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_G_b_32(file, dset_out)

def trexio_write_safe_cell_G_b_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_G_b_32(file, dset_in)

def trexio_read_safe_cell_G_b_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_G_b_64(file, dset_out)

def trexio_write_safe_cell_G_b_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_G_b_64(file, dset_in)

def trexio_has_cell_G_c(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_cell_G_c(file)

def trexio_read_cell_G_c(file: "trexio_s", cell_G_c: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_G_c(file, cell_G_c)

def trexio_write_cell_G_c(file: "trexio_s", cell_G_c: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_G_c(file, cell_G_c)

def trexio_read_cell_G_c_32(file: "trexio_s", cell_G_c: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_G_c_32(file, cell_G_c)

def trexio_write_cell_G_c_32(file: "trexio_s", cell_G_c: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_G_c_32(file, cell_G_c)

def trexio_read_cell_G_c_64(file: "trexio_s", cell_G_c: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_cell_G_c_64(file, cell_G_c)

def trexio_write_cell_G_c_64(file: "trexio_s", cell_G_c: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_cell_G_c_64(file, cell_G_c)

def trexio_read_safe_cell_G_c(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_G_c(file, dset_out)

def trexio_write_safe_cell_G_c(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_G_c(file, dset_in)

def trexio_read_safe_cell_G_c_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_G_c_32(file, dset_out)

def trexio_write_safe_cell_G_c_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_G_c_32(file, dset_in)

def trexio_read_safe_cell_G_c_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_cell_G_c_64(file, dset_out)

def trexio_write_safe_cell_G_c_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_cell_G_c_64(file, dset_in)

def trexio_has_pbc_k_point(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_pbc_k_point(file)

def trexio_read_pbc_k_point(file: "trexio_s", pbc_k_point: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_pbc_k_point(file, pbc_k_point)

def trexio_write_pbc_k_point(file: "trexio_s", pbc_k_point: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_pbc_k_point(file, pbc_k_point)

def trexio_read_pbc_k_point_32(file: "trexio_s", pbc_k_point: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_pbc_k_point_32(file, pbc_k_point)

def trexio_write_pbc_k_point_32(file: "trexio_s", pbc_k_point: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_pbc_k_point_32(file, pbc_k_point)

def trexio_read_pbc_k_point_64(file: "trexio_s", pbc_k_point: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_pbc_k_point_64(file, pbc_k_point)

def trexio_write_pbc_k_point_64(file: "trexio_s", pbc_k_point: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_pbc_k_point_64(file, pbc_k_point)

def trexio_read_safe_pbc_k_point(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_pbc_k_point(file, dset_out)

def trexio_write_safe_pbc_k_point(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_pbc_k_point(file, dset_in)

def trexio_read_safe_pbc_k_point_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_pbc_k_point_32(file, dset_out)

def trexio_write_safe_pbc_k_point_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_pbc_k_point_32(file, dset_in)

def trexio_read_safe_pbc_k_point_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_pbc_k_point_64(file, dset_out)

def trexio_write_safe_pbc_k_point_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_pbc_k_point_64(file, dset_in)

def trexio_has_basis_nucleus_index(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_nucleus_index(file)

def trexio_read_basis_nucleus_index(file: "trexio_s", basis_nucleus_index: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_nucleus_index(file, basis_nucleus_index)

def trexio_write_basis_nucleus_index(file: "trexio_s", basis_nucleus_index: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_nucleus_index(file, basis_nucleus_index)

def trexio_read_basis_nucleus_index_32(file: "trexio_s", basis_nucleus_index: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_nucleus_index_32(file, basis_nucleus_index)

def trexio_write_basis_nucleus_index_32(file: "trexio_s", basis_nucleus_index: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_nucleus_index_32(file, basis_nucleus_index)

def trexio_read_basis_nucleus_index_64(file: "trexio_s", basis_nucleus_index: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_nucleus_index_64(file, basis_nucleus_index)

def trexio_write_basis_nucleus_index_64(file: "trexio_s", basis_nucleus_index: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_nucleus_index_64(file, basis_nucleus_index)

def trexio_read_safe_basis_nucleus_index(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_nucleus_index(file, dset_out)

def trexio_write_safe_basis_nucleus_index(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_nucleus_index(file, dset_in)

def trexio_read_safe_basis_nucleus_index_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_nucleus_index_32(file, dset_out)

def trexio_write_safe_basis_nucleus_index_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_nucleus_index_32(file, dset_in)

def trexio_read_safe_basis_nucleus_index_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_nucleus_index_64(file, dset_out)

def trexio_write_safe_basis_nucleus_index_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_nucleus_index_64(file, dset_in)

def trexio_has_basis_shell_ang_mom(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_shell_ang_mom(file)

def trexio_read_basis_shell_ang_mom(file: "trexio_s", basis_shell_ang_mom: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_shell_ang_mom(file, basis_shell_ang_mom)

def trexio_write_basis_shell_ang_mom(file: "trexio_s", basis_shell_ang_mom: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_ang_mom(file, basis_shell_ang_mom)

def trexio_read_basis_shell_ang_mom_32(file: "trexio_s", basis_shell_ang_mom: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_shell_ang_mom_32(file, basis_shell_ang_mom)

def trexio_write_basis_shell_ang_mom_32(file: "trexio_s", basis_shell_ang_mom: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_ang_mom_32(file, basis_shell_ang_mom)

def trexio_read_basis_shell_ang_mom_64(file: "trexio_s", basis_shell_ang_mom: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_shell_ang_mom_64(file, basis_shell_ang_mom)

def trexio_write_basis_shell_ang_mom_64(file: "trexio_s", basis_shell_ang_mom: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_ang_mom_64(file, basis_shell_ang_mom)

def trexio_read_safe_basis_shell_ang_mom(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_shell_ang_mom(file, dset_out)

def trexio_write_safe_basis_shell_ang_mom(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_shell_ang_mom(file, dset_in)

def trexio_read_safe_basis_shell_ang_mom_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_shell_ang_mom_32(file, dset_out)

def trexio_write_safe_basis_shell_ang_mom_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_shell_ang_mom_32(file, dset_in)

def trexio_read_safe_basis_shell_ang_mom_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_shell_ang_mom_64(file, dset_out)

def trexio_write_safe_basis_shell_ang_mom_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_shell_ang_mom_64(file, dset_in)

def trexio_has_basis_shell_factor(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_shell_factor(file)

def trexio_read_basis_shell_factor(file: "trexio_s", basis_shell_factor: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_shell_factor(file, basis_shell_factor)

def trexio_write_basis_shell_factor(file: "trexio_s", basis_shell_factor: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_factor(file, basis_shell_factor)

def trexio_read_basis_shell_factor_32(file: "trexio_s", basis_shell_factor: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_shell_factor_32(file, basis_shell_factor)

def trexio_write_basis_shell_factor_32(file: "trexio_s", basis_shell_factor: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_factor_32(file, basis_shell_factor)

def trexio_read_basis_shell_factor_64(file: "trexio_s", basis_shell_factor: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_shell_factor_64(file, basis_shell_factor)

def trexio_write_basis_shell_factor_64(file: "trexio_s", basis_shell_factor: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_factor_64(file, basis_shell_factor)

def trexio_read_safe_basis_shell_factor(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_shell_factor(file, dset_out)

def trexio_write_safe_basis_shell_factor(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_shell_factor(file, dset_in)

def trexio_read_safe_basis_shell_factor_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_shell_factor_32(file, dset_out)

def trexio_write_safe_basis_shell_factor_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_shell_factor_32(file, dset_in)

def trexio_read_safe_basis_shell_factor_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_shell_factor_64(file, dset_out)

def trexio_write_safe_basis_shell_factor_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_shell_factor_64(file, dset_in)

def trexio_has_basis_r_power(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_r_power(file)

def trexio_read_basis_r_power(file: "trexio_s", basis_r_power: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_r_power(file, basis_r_power)

def trexio_write_basis_r_power(file: "trexio_s", basis_r_power: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_r_power(file, basis_r_power)

def trexio_read_basis_r_power_32(file: "trexio_s", basis_r_power: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_r_power_32(file, basis_r_power)

def trexio_write_basis_r_power_32(file: "trexio_s", basis_r_power: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_r_power_32(file, basis_r_power)

def trexio_read_basis_r_power_64(file: "trexio_s", basis_r_power: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_r_power_64(file, basis_r_power)

def trexio_write_basis_r_power_64(file: "trexio_s", basis_r_power: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_r_power_64(file, basis_r_power)

def trexio_read_safe_basis_r_power(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_r_power(file, dset_out)

def trexio_write_safe_basis_r_power(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_r_power(file, dset_in)

def trexio_read_safe_basis_r_power_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_r_power_32(file, dset_out)

def trexio_write_safe_basis_r_power_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_r_power_32(file, dset_in)

def trexio_read_safe_basis_r_power_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_r_power_64(file, dset_out)

def trexio_write_safe_basis_r_power_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_r_power_64(file, dset_in)

def trexio_has_basis_shell_index(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_shell_index(file)

def trexio_read_basis_shell_index(file: "trexio_s", basis_shell_index: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_shell_index(file, basis_shell_index)

def trexio_write_basis_shell_index(file: "trexio_s", basis_shell_index: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_index(file, basis_shell_index)

def trexio_read_basis_shell_index_32(file: "trexio_s", basis_shell_index: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_shell_index_32(file, basis_shell_index)

def trexio_write_basis_shell_index_32(file: "trexio_s", basis_shell_index: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_index_32(file, basis_shell_index)

def trexio_read_basis_shell_index_64(file: "trexio_s", basis_shell_index: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_shell_index_64(file, basis_shell_index)

def trexio_write_basis_shell_index_64(file: "trexio_s", basis_shell_index: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_shell_index_64(file, basis_shell_index)

def trexio_read_safe_basis_shell_index(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_shell_index(file, dset_out)

def trexio_write_safe_basis_shell_index(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_shell_index(file, dset_in)

def trexio_read_safe_basis_shell_index_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_shell_index_32(file, dset_out)

def trexio_write_safe_basis_shell_index_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_shell_index_32(file, dset_in)

def trexio_read_safe_basis_shell_index_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_shell_index_64(file, dset_out)

def trexio_write_safe_basis_shell_index_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_shell_index_64(file, dset_in)

def trexio_has_basis_exponent(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_exponent(file)

def trexio_read_basis_exponent(file: "trexio_s", basis_exponent: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_exponent(file, basis_exponent)

def trexio_write_basis_exponent(file: "trexio_s", basis_exponent: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_exponent(file, basis_exponent)

def trexio_read_basis_exponent_32(file: "trexio_s", basis_exponent: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_exponent_32(file, basis_exponent)

def trexio_write_basis_exponent_32(file: "trexio_s", basis_exponent: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_exponent_32(file, basis_exponent)

def trexio_read_basis_exponent_64(file: "trexio_s", basis_exponent: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_exponent_64(file, basis_exponent)

def trexio_write_basis_exponent_64(file: "trexio_s", basis_exponent: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_exponent_64(file, basis_exponent)

def trexio_read_safe_basis_exponent(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_exponent(file, dset_out)

def trexio_write_safe_basis_exponent(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_exponent(file, dset_in)

def trexio_read_safe_basis_exponent_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_exponent_32(file, dset_out)

def trexio_write_safe_basis_exponent_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_exponent_32(file, dset_in)

def trexio_read_safe_basis_exponent_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_exponent_64(file, dset_out)

def trexio_write_safe_basis_exponent_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_exponent_64(file, dset_in)

def trexio_has_basis_coefficient(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_coefficient(file)

def trexio_read_basis_coefficient(file: "trexio_s", basis_coefficient: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_coefficient(file, basis_coefficient)

def trexio_write_basis_coefficient(file: "trexio_s", basis_coefficient: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_coefficient(file, basis_coefficient)

def trexio_read_basis_coefficient_32(file: "trexio_s", basis_coefficient: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_coefficient_32(file, basis_coefficient)

def trexio_write_basis_coefficient_32(file: "trexio_s", basis_coefficient: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_coefficient_32(file, basis_coefficient)

def trexio_read_basis_coefficient_64(file: "trexio_s", basis_coefficient: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_coefficient_64(file, basis_coefficient)

def trexio_write_basis_coefficient_64(file: "trexio_s", basis_coefficient: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_coefficient_64(file, basis_coefficient)

def trexio_read_safe_basis_coefficient(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_coefficient(file, dset_out)

def trexio_write_safe_basis_coefficient(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_coefficient(file, dset_in)

def trexio_read_safe_basis_coefficient_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_coefficient_32(file, dset_out)

def trexio_write_safe_basis_coefficient_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_coefficient_32(file, dset_in)

def trexio_read_safe_basis_coefficient_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_coefficient_64(file, dset_out)

def trexio_write_safe_basis_coefficient_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_coefficient_64(file, dset_in)

def trexio_has_basis_prim_factor(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis_prim_factor(file)

def trexio_read_basis_prim_factor(file: "trexio_s", basis_prim_factor: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_prim_factor(file, basis_prim_factor)

def trexio_write_basis_prim_factor(file: "trexio_s", basis_prim_factor: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_prim_factor(file, basis_prim_factor)

def trexio_read_basis_prim_factor_32(file: "trexio_s", basis_prim_factor: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_prim_factor_32(file, basis_prim_factor)

def trexio_write_basis_prim_factor_32(file: "trexio_s", basis_prim_factor: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_prim_factor_32(file, basis_prim_factor)

def trexio_read_basis_prim_factor_64(file: "trexio_s", basis_prim_factor: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_basis_prim_factor_64(file, basis_prim_factor)

def trexio_write_basis_prim_factor_64(file: "trexio_s", basis_prim_factor: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_basis_prim_factor_64(file, basis_prim_factor)

def trexio_read_safe_basis_prim_factor(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_prim_factor(file, dset_out)

def trexio_write_safe_basis_prim_factor(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_prim_factor(file, dset_in)

def trexio_read_safe_basis_prim_factor_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_prim_factor_32(file, dset_out)

def trexio_write_safe_basis_prim_factor_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_prim_factor_32(file, dset_in)

def trexio_read_safe_basis_prim_factor_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_basis_prim_factor_64(file, dset_out)

def trexio_write_safe_basis_prim_factor_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_basis_prim_factor_64(file, dset_in)

def trexio_has_ecp_max_ang_mom_plus_1(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ecp_max_ang_mom_plus_1(file)

def trexio_read_ecp_max_ang_mom_plus_1(file: "trexio_s", ecp_max_ang_mom_plus_1: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_max_ang_mom_plus_1(file, ecp_max_ang_mom_plus_1)

def trexio_write_ecp_max_ang_mom_plus_1(file: "trexio_s", ecp_max_ang_mom_plus_1: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_max_ang_mom_plus_1(file, ecp_max_ang_mom_plus_1)

def trexio_read_ecp_max_ang_mom_plus_1_32(file: "trexio_s", ecp_max_ang_mom_plus_1: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_max_ang_mom_plus_1_32(file, ecp_max_ang_mom_plus_1)

def trexio_write_ecp_max_ang_mom_plus_1_32(file: "trexio_s", ecp_max_ang_mom_plus_1: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_max_ang_mom_plus_1_32(file, ecp_max_ang_mom_plus_1)

def trexio_read_ecp_max_ang_mom_plus_1_64(file: "trexio_s", ecp_max_ang_mom_plus_1: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_max_ang_mom_plus_1_64(file, ecp_max_ang_mom_plus_1)

def trexio_write_ecp_max_ang_mom_plus_1_64(file: "trexio_s", ecp_max_ang_mom_plus_1: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_max_ang_mom_plus_1_64(file, ecp_max_ang_mom_plus_1)

def trexio_read_safe_ecp_max_ang_mom_plus_1(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_max_ang_mom_plus_1(file, dset_out)

def trexio_write_safe_ecp_max_ang_mom_plus_1(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_max_ang_mom_plus_1(file, dset_in)

def trexio_read_safe_ecp_max_ang_mom_plus_1_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_max_ang_mom_plus_1_32(file, dset_out)

def trexio_write_safe_ecp_max_ang_mom_plus_1_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_max_ang_mom_plus_1_32(file, dset_in)

def trexio_read_safe_ecp_max_ang_mom_plus_1_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_max_ang_mom_plus_1_64(file, dset_out)

def trexio_write_safe_ecp_max_ang_mom_plus_1_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_max_ang_mom_plus_1_64(file, dset_in)

def trexio_has_ecp_z_core(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ecp_z_core(file)

def trexio_read_ecp_z_core(file: "trexio_s", ecp_z_core: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_z_core(file, ecp_z_core)

def trexio_write_ecp_z_core(file: "trexio_s", ecp_z_core: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_z_core(file, ecp_z_core)

def trexio_read_ecp_z_core_32(file: "trexio_s", ecp_z_core: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_z_core_32(file, ecp_z_core)

def trexio_write_ecp_z_core_32(file: "trexio_s", ecp_z_core: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_z_core_32(file, ecp_z_core)

def trexio_read_ecp_z_core_64(file: "trexio_s", ecp_z_core: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_z_core_64(file, ecp_z_core)

def trexio_write_ecp_z_core_64(file: "trexio_s", ecp_z_core: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_z_core_64(file, ecp_z_core)

def trexio_read_safe_ecp_z_core(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_z_core(file, dset_out)

def trexio_write_safe_ecp_z_core(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_z_core(file, dset_in)

def trexio_read_safe_ecp_z_core_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_z_core_32(file, dset_out)

def trexio_write_safe_ecp_z_core_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_z_core_32(file, dset_in)

def trexio_read_safe_ecp_z_core_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_z_core_64(file, dset_out)

def trexio_write_safe_ecp_z_core_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_z_core_64(file, dset_in)

def trexio_has_ecp_ang_mom(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ecp_ang_mom(file)

def trexio_read_ecp_ang_mom(file: "trexio_s", ecp_ang_mom: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_ang_mom(file, ecp_ang_mom)

def trexio_write_ecp_ang_mom(file: "trexio_s", ecp_ang_mom: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_ang_mom(file, ecp_ang_mom)

def trexio_read_ecp_ang_mom_32(file: "trexio_s", ecp_ang_mom: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_ang_mom_32(file, ecp_ang_mom)

def trexio_write_ecp_ang_mom_32(file: "trexio_s", ecp_ang_mom: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_ang_mom_32(file, ecp_ang_mom)

def trexio_read_ecp_ang_mom_64(file: "trexio_s", ecp_ang_mom: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_ang_mom_64(file, ecp_ang_mom)

def trexio_write_ecp_ang_mom_64(file: "trexio_s", ecp_ang_mom: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_ang_mom_64(file, ecp_ang_mom)

def trexio_read_safe_ecp_ang_mom(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_ang_mom(file, dset_out)

def trexio_write_safe_ecp_ang_mom(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_ang_mom(file, dset_in)

def trexio_read_safe_ecp_ang_mom_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_ang_mom_32(file, dset_out)

def trexio_write_safe_ecp_ang_mom_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_ang_mom_32(file, dset_in)

def trexio_read_safe_ecp_ang_mom_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_ang_mom_64(file, dset_out)

def trexio_write_safe_ecp_ang_mom_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_ang_mom_64(file, dset_in)

def trexio_has_ecp_nucleus_index(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ecp_nucleus_index(file)

def trexio_read_ecp_nucleus_index(file: "trexio_s", ecp_nucleus_index: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_nucleus_index(file, ecp_nucleus_index)

def trexio_write_ecp_nucleus_index(file: "trexio_s", ecp_nucleus_index: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_nucleus_index(file, ecp_nucleus_index)

def trexio_read_ecp_nucleus_index_32(file: "trexio_s", ecp_nucleus_index: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_nucleus_index_32(file, ecp_nucleus_index)

def trexio_write_ecp_nucleus_index_32(file: "trexio_s", ecp_nucleus_index: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_nucleus_index_32(file, ecp_nucleus_index)

def trexio_read_ecp_nucleus_index_64(file: "trexio_s", ecp_nucleus_index: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_nucleus_index_64(file, ecp_nucleus_index)

def trexio_write_ecp_nucleus_index_64(file: "trexio_s", ecp_nucleus_index: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_nucleus_index_64(file, ecp_nucleus_index)

def trexio_read_safe_ecp_nucleus_index(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_nucleus_index(file, dset_out)

def trexio_write_safe_ecp_nucleus_index(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_nucleus_index(file, dset_in)

def trexio_read_safe_ecp_nucleus_index_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_nucleus_index_32(file, dset_out)

def trexio_write_safe_ecp_nucleus_index_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_nucleus_index_32(file, dset_in)

def trexio_read_safe_ecp_nucleus_index_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_nucleus_index_64(file, dset_out)

def trexio_write_safe_ecp_nucleus_index_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_nucleus_index_64(file, dset_in)

def trexio_has_ecp_exponent(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ecp_exponent(file)

def trexio_read_ecp_exponent(file: "trexio_s", ecp_exponent: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_exponent(file, ecp_exponent)

def trexio_write_ecp_exponent(file: "trexio_s", ecp_exponent: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_exponent(file, ecp_exponent)

def trexio_read_ecp_exponent_32(file: "trexio_s", ecp_exponent: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_exponent_32(file, ecp_exponent)

def trexio_write_ecp_exponent_32(file: "trexio_s", ecp_exponent: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_exponent_32(file, ecp_exponent)

def trexio_read_ecp_exponent_64(file: "trexio_s", ecp_exponent: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_exponent_64(file, ecp_exponent)

def trexio_write_ecp_exponent_64(file: "trexio_s", ecp_exponent: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_exponent_64(file, ecp_exponent)

def trexio_read_safe_ecp_exponent(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_exponent(file, dset_out)

def trexio_write_safe_ecp_exponent(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_exponent(file, dset_in)

def trexio_read_safe_ecp_exponent_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_exponent_32(file, dset_out)

def trexio_write_safe_ecp_exponent_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_exponent_32(file, dset_in)

def trexio_read_safe_ecp_exponent_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_exponent_64(file, dset_out)

def trexio_write_safe_ecp_exponent_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_exponent_64(file, dset_in)

def trexio_has_ecp_coefficient(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ecp_coefficient(file)

def trexio_read_ecp_coefficient(file: "trexio_s", ecp_coefficient: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_coefficient(file, ecp_coefficient)

def trexio_write_ecp_coefficient(file: "trexio_s", ecp_coefficient: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_coefficient(file, ecp_coefficient)

def trexio_read_ecp_coefficient_32(file: "trexio_s", ecp_coefficient: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_coefficient_32(file, ecp_coefficient)

def trexio_write_ecp_coefficient_32(file: "trexio_s", ecp_coefficient: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_coefficient_32(file, ecp_coefficient)

def trexio_read_ecp_coefficient_64(file: "trexio_s", ecp_coefficient: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_coefficient_64(file, ecp_coefficient)

def trexio_write_ecp_coefficient_64(file: "trexio_s", ecp_coefficient: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_coefficient_64(file, ecp_coefficient)

def trexio_read_safe_ecp_coefficient(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_coefficient(file, dset_out)

def trexio_write_safe_ecp_coefficient(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_coefficient(file, dset_in)

def trexio_read_safe_ecp_coefficient_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_coefficient_32(file, dset_out)

def trexio_write_safe_ecp_coefficient_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_coefficient_32(file, dset_in)

def trexio_read_safe_ecp_coefficient_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_coefficient_64(file, dset_out)

def trexio_write_safe_ecp_coefficient_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_coefficient_64(file, dset_in)

def trexio_has_ecp_power(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ecp_power(file)

def trexio_read_ecp_power(file: "trexio_s", ecp_power: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_power(file, ecp_power)

def trexio_write_ecp_power(file: "trexio_s", ecp_power: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_power(file, ecp_power)

def trexio_read_ecp_power_32(file: "trexio_s", ecp_power: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_power_32(file, ecp_power)

def trexio_write_ecp_power_32(file: "trexio_s", ecp_power: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_power_32(file, ecp_power)

def trexio_read_ecp_power_64(file: "trexio_s", ecp_power: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ecp_power_64(file, ecp_power)

def trexio_write_ecp_power_64(file: "trexio_s", ecp_power: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ecp_power_64(file, ecp_power)

def trexio_read_safe_ecp_power(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_power(file, dset_out)

def trexio_write_safe_ecp_power(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_power(file, dset_in)

def trexio_read_safe_ecp_power_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_power_32(file, dset_out)

def trexio_write_safe_ecp_power_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_power_32(file, dset_in)

def trexio_read_safe_ecp_power_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ecp_power_64(file, dset_out)

def trexio_write_safe_ecp_power_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ecp_power_64(file, dset_in)

def trexio_has_grid_coord(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_coord(file)

def trexio_read_grid_coord(file: "trexio_s", grid_coord: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_coord(file, grid_coord)

def trexio_write_grid_coord(file: "trexio_s", grid_coord: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_coord(file, grid_coord)

def trexio_read_grid_coord_32(file: "trexio_s", grid_coord: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_coord_32(file, grid_coord)

def trexio_write_grid_coord_32(file: "trexio_s", grid_coord: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_coord_32(file, grid_coord)

def trexio_read_grid_coord_64(file: "trexio_s", grid_coord: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_coord_64(file, grid_coord)

def trexio_write_grid_coord_64(file: "trexio_s", grid_coord: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_coord_64(file, grid_coord)

def trexio_read_safe_grid_coord(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_coord(file, dset_out)

def trexio_write_safe_grid_coord(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_coord(file, dset_in)

def trexio_read_safe_grid_coord_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_coord_32(file, dset_out)

def trexio_write_safe_grid_coord_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_coord_32(file, dset_in)

def trexio_read_safe_grid_coord_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_coord_64(file, dset_out)

def trexio_write_safe_grid_coord_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_coord_64(file, dset_in)

def trexio_has_grid_weight(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_weight(file)

def trexio_read_grid_weight(file: "trexio_s", grid_weight: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_weight(file, grid_weight)

def trexio_write_grid_weight(file: "trexio_s", grid_weight: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_weight(file, grid_weight)

def trexio_read_grid_weight_32(file: "trexio_s", grid_weight: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_weight_32(file, grid_weight)

def trexio_write_grid_weight_32(file: "trexio_s", grid_weight: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_weight_32(file, grid_weight)

def trexio_read_grid_weight_64(file: "trexio_s", grid_weight: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_weight_64(file, grid_weight)

def trexio_write_grid_weight_64(file: "trexio_s", grid_weight: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_weight_64(file, grid_weight)

def trexio_read_safe_grid_weight(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_weight(file, dset_out)

def trexio_write_safe_grid_weight(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_weight(file, dset_in)

def trexio_read_safe_grid_weight_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_weight_32(file, dset_out)

def trexio_write_safe_grid_weight_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_weight_32(file, dset_in)

def trexio_read_safe_grid_weight_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_weight_64(file, dset_out)

def trexio_write_safe_grid_weight_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_weight_64(file, dset_in)

def trexio_has_grid_ang_coord(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_ang_coord(file)

def trexio_read_grid_ang_coord(file: "trexio_s", grid_ang_coord: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_ang_coord(file, grid_ang_coord)

def trexio_write_grid_ang_coord(file: "trexio_s", grid_ang_coord: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_ang_coord(file, grid_ang_coord)

def trexio_read_grid_ang_coord_32(file: "trexio_s", grid_ang_coord: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_ang_coord_32(file, grid_ang_coord)

def trexio_write_grid_ang_coord_32(file: "trexio_s", grid_ang_coord: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_ang_coord_32(file, grid_ang_coord)

def trexio_read_grid_ang_coord_64(file: "trexio_s", grid_ang_coord: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_ang_coord_64(file, grid_ang_coord)

def trexio_write_grid_ang_coord_64(file: "trexio_s", grid_ang_coord: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_ang_coord_64(file, grid_ang_coord)

def trexio_read_safe_grid_ang_coord(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_ang_coord(file, dset_out)

def trexio_write_safe_grid_ang_coord(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_ang_coord(file, dset_in)

def trexio_read_safe_grid_ang_coord_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_ang_coord_32(file, dset_out)

def trexio_write_safe_grid_ang_coord_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_ang_coord_32(file, dset_in)

def trexio_read_safe_grid_ang_coord_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_ang_coord_64(file, dset_out)

def trexio_write_safe_grid_ang_coord_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_ang_coord_64(file, dset_in)

def trexio_has_grid_ang_weight(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_ang_weight(file)

def trexio_read_grid_ang_weight(file: "trexio_s", grid_ang_weight: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_ang_weight(file, grid_ang_weight)

def trexio_write_grid_ang_weight(file: "trexio_s", grid_ang_weight: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_ang_weight(file, grid_ang_weight)

def trexio_read_grid_ang_weight_32(file: "trexio_s", grid_ang_weight: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_ang_weight_32(file, grid_ang_weight)

def trexio_write_grid_ang_weight_32(file: "trexio_s", grid_ang_weight: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_ang_weight_32(file, grid_ang_weight)

def trexio_read_grid_ang_weight_64(file: "trexio_s", grid_ang_weight: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_ang_weight_64(file, grid_ang_weight)

def trexio_write_grid_ang_weight_64(file: "trexio_s", grid_ang_weight: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_ang_weight_64(file, grid_ang_weight)

def trexio_read_safe_grid_ang_weight(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_ang_weight(file, dset_out)

def trexio_write_safe_grid_ang_weight(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_ang_weight(file, dset_in)

def trexio_read_safe_grid_ang_weight_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_ang_weight_32(file, dset_out)

def trexio_write_safe_grid_ang_weight_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_ang_weight_32(file, dset_in)

def trexio_read_safe_grid_ang_weight_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_ang_weight_64(file, dset_out)

def trexio_write_safe_grid_ang_weight_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_ang_weight_64(file, dset_in)

def trexio_has_grid_rad_coord(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_rad_coord(file)

def trexio_read_grid_rad_coord(file: "trexio_s", grid_rad_coord: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_rad_coord(file, grid_rad_coord)

def trexio_write_grid_rad_coord(file: "trexio_s", grid_rad_coord: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_coord(file, grid_rad_coord)

def trexio_read_grid_rad_coord_32(file: "trexio_s", grid_rad_coord: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_rad_coord_32(file, grid_rad_coord)

def trexio_write_grid_rad_coord_32(file: "trexio_s", grid_rad_coord: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_coord_32(file, grid_rad_coord)

def trexio_read_grid_rad_coord_64(file: "trexio_s", grid_rad_coord: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_rad_coord_64(file, grid_rad_coord)

def trexio_write_grid_rad_coord_64(file: "trexio_s", grid_rad_coord: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_coord_64(file, grid_rad_coord)

def trexio_read_safe_grid_rad_coord(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_rad_coord(file, dset_out)

def trexio_write_safe_grid_rad_coord(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_rad_coord(file, dset_in)

def trexio_read_safe_grid_rad_coord_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_rad_coord_32(file, dset_out)

def trexio_write_safe_grid_rad_coord_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_rad_coord_32(file, dset_in)

def trexio_read_safe_grid_rad_coord_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_rad_coord_64(file, dset_out)

def trexio_write_safe_grid_rad_coord_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_rad_coord_64(file, dset_in)

def trexio_has_grid_rad_weight(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid_rad_weight(file)

def trexio_read_grid_rad_weight(file: "trexio_s", grid_rad_weight: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_rad_weight(file, grid_rad_weight)

def trexio_write_grid_rad_weight(file: "trexio_s", grid_rad_weight: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_weight(file, grid_rad_weight)

def trexio_read_grid_rad_weight_32(file: "trexio_s", grid_rad_weight: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_rad_weight_32(file, grid_rad_weight)

def trexio_write_grid_rad_weight_32(file: "trexio_s", grid_rad_weight: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_weight_32(file, grid_rad_weight)

def trexio_read_grid_rad_weight_64(file: "trexio_s", grid_rad_weight: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_grid_rad_weight_64(file, grid_rad_weight)

def trexio_write_grid_rad_weight_64(file: "trexio_s", grid_rad_weight: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_grid_rad_weight_64(file, grid_rad_weight)

def trexio_read_safe_grid_rad_weight(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_rad_weight(file, dset_out)

def trexio_write_safe_grid_rad_weight(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_rad_weight(file, dset_in)

def trexio_read_safe_grid_rad_weight_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_rad_weight_32(file, dset_out)

def trexio_write_safe_grid_rad_weight_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_rad_weight_32(file, dset_in)

def trexio_read_safe_grid_rad_weight_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_grid_rad_weight_64(file, dset_out)

def trexio_write_safe_grid_rad_weight_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_grid_rad_weight_64(file, dset_in)

def trexio_has_ao_shell(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_shell(file)

def trexio_read_ao_shell(file: "trexio_s", ao_shell: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_shell(file, ao_shell)

def trexio_write_ao_shell(file: "trexio_s", ao_shell: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_shell(file, ao_shell)

def trexio_read_ao_shell_32(file: "trexio_s", ao_shell: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_shell_32(file, ao_shell)

def trexio_write_ao_shell_32(file: "trexio_s", ao_shell: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_shell_32(file, ao_shell)

def trexio_read_ao_shell_64(file: "trexio_s", ao_shell: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_shell_64(file, ao_shell)

def trexio_write_ao_shell_64(file: "trexio_s", ao_shell: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_shell_64(file, ao_shell)

def trexio_read_safe_ao_shell(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_shell(file, dset_out)

def trexio_write_safe_ao_shell(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_shell(file, dset_in)

def trexio_read_safe_ao_shell_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_shell_32(file, dset_out)

def trexio_write_safe_ao_shell_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_shell_32(file, dset_in)

def trexio_read_safe_ao_shell_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_shell_64(file, dset_out)

def trexio_write_safe_ao_shell_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_shell_64(file, dset_in)

def trexio_has_ao_normalization(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_normalization(file)

def trexio_read_ao_normalization(file: "trexio_s", ao_normalization: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_normalization(file, ao_normalization)

def trexio_write_ao_normalization(file: "trexio_s", ao_normalization: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_normalization(file, ao_normalization)

def trexio_read_ao_normalization_32(file: "trexio_s", ao_normalization: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_normalization_32(file, ao_normalization)

def trexio_write_ao_normalization_32(file: "trexio_s", ao_normalization: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_normalization_32(file, ao_normalization)

def trexio_read_ao_normalization_64(file: "trexio_s", ao_normalization: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_normalization_64(file, ao_normalization)

def trexio_write_ao_normalization_64(file: "trexio_s", ao_normalization: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_normalization_64(file, ao_normalization)

def trexio_read_safe_ao_normalization(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_normalization(file, dset_out)

def trexio_write_safe_ao_normalization(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_normalization(file, dset_in)

def trexio_read_safe_ao_normalization_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_normalization_32(file, dset_out)

def trexio_write_safe_ao_normalization_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_normalization_32(file, dset_in)

def trexio_read_safe_ao_normalization_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_normalization_64(file, dset_out)

def trexio_write_safe_ao_normalization_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_normalization_64(file, dset_in)

def trexio_has_ao_1e_int_overlap(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int_overlap(file)

def trexio_read_ao_1e_int_overlap(file: "trexio_s", ao_1e_int_overlap: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_overlap(file, ao_1e_int_overlap)

def trexio_write_ao_1e_int_overlap(file: "trexio_s", ao_1e_int_overlap: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_overlap(file, ao_1e_int_overlap)

def trexio_read_ao_1e_int_overlap_32(file: "trexio_s", ao_1e_int_overlap: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_overlap_32(file, ao_1e_int_overlap)

def trexio_write_ao_1e_int_overlap_32(file: "trexio_s", ao_1e_int_overlap: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_overlap_32(file, ao_1e_int_overlap)

def trexio_read_ao_1e_int_overlap_64(file: "trexio_s", ao_1e_int_overlap: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_overlap_64(file, ao_1e_int_overlap)

def trexio_write_ao_1e_int_overlap_64(file: "trexio_s", ao_1e_int_overlap: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_overlap_64(file, ao_1e_int_overlap)

def trexio_read_safe_ao_1e_int_overlap(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_overlap(file, dset_out)

def trexio_write_safe_ao_1e_int_overlap(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_overlap(file, dset_in)

def trexio_read_safe_ao_1e_int_overlap_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_overlap_32(file, dset_out)

def trexio_write_safe_ao_1e_int_overlap_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_overlap_32(file, dset_in)

def trexio_read_safe_ao_1e_int_overlap_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_overlap_64(file, dset_out)

def trexio_write_safe_ao_1e_int_overlap_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_overlap_64(file, dset_in)

def trexio_has_ao_1e_int_kinetic(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int_kinetic(file)

def trexio_read_ao_1e_int_kinetic(file: "trexio_s", ao_1e_int_kinetic: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_kinetic(file, ao_1e_int_kinetic)

def trexio_write_ao_1e_int_kinetic(file: "trexio_s", ao_1e_int_kinetic: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_kinetic(file, ao_1e_int_kinetic)

def trexio_read_ao_1e_int_kinetic_32(file: "trexio_s", ao_1e_int_kinetic: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_kinetic_32(file, ao_1e_int_kinetic)

def trexio_write_ao_1e_int_kinetic_32(file: "trexio_s", ao_1e_int_kinetic: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_kinetic_32(file, ao_1e_int_kinetic)

def trexio_read_ao_1e_int_kinetic_64(file: "trexio_s", ao_1e_int_kinetic: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_kinetic_64(file, ao_1e_int_kinetic)

def trexio_write_ao_1e_int_kinetic_64(file: "trexio_s", ao_1e_int_kinetic: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_kinetic_64(file, ao_1e_int_kinetic)

def trexio_read_safe_ao_1e_int_kinetic(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_kinetic(file, dset_out)

def trexio_write_safe_ao_1e_int_kinetic(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_kinetic(file, dset_in)

def trexio_read_safe_ao_1e_int_kinetic_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_kinetic_32(file, dset_out)

def trexio_write_safe_ao_1e_int_kinetic_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_kinetic_32(file, dset_in)

def trexio_read_safe_ao_1e_int_kinetic_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_kinetic_64(file, dset_out)

def trexio_write_safe_ao_1e_int_kinetic_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_kinetic_64(file, dset_in)

def trexio_has_ao_1e_int_potential_n_e(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int_potential_n_e(file)

def trexio_read_ao_1e_int_potential_n_e(file: "trexio_s", ao_1e_int_potential_n_e: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_potential_n_e(file, ao_1e_int_potential_n_e)

def trexio_write_ao_1e_int_potential_n_e(file: "trexio_s", ao_1e_int_potential_n_e: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_potential_n_e(file, ao_1e_int_potential_n_e)

def trexio_read_ao_1e_int_potential_n_e_32(file: "trexio_s", ao_1e_int_potential_n_e: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_potential_n_e_32(file, ao_1e_int_potential_n_e)

def trexio_write_ao_1e_int_potential_n_e_32(file: "trexio_s", ao_1e_int_potential_n_e: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_potential_n_e_32(file, ao_1e_int_potential_n_e)

def trexio_read_ao_1e_int_potential_n_e_64(file: "trexio_s", ao_1e_int_potential_n_e: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_potential_n_e_64(file, ao_1e_int_potential_n_e)

def trexio_write_ao_1e_int_potential_n_e_64(file: "trexio_s", ao_1e_int_potential_n_e: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_potential_n_e_64(file, ao_1e_int_potential_n_e)

def trexio_read_safe_ao_1e_int_potential_n_e(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_potential_n_e(file, dset_out)

def trexio_write_safe_ao_1e_int_potential_n_e(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_potential_n_e(file, dset_in)

def trexio_read_safe_ao_1e_int_potential_n_e_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_potential_n_e_32(file, dset_out)

def trexio_write_safe_ao_1e_int_potential_n_e_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_potential_n_e_32(file, dset_in)

def trexio_read_safe_ao_1e_int_potential_n_e_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_potential_n_e_64(file, dset_out)

def trexio_write_safe_ao_1e_int_potential_n_e_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_potential_n_e_64(file, dset_in)

def trexio_has_ao_1e_int_ecp(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int_ecp(file)

def trexio_read_ao_1e_int_ecp(file: "trexio_s", ao_1e_int_ecp: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_ecp(file, ao_1e_int_ecp)

def trexio_write_ao_1e_int_ecp(file: "trexio_s", ao_1e_int_ecp: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_ecp(file, ao_1e_int_ecp)

def trexio_read_ao_1e_int_ecp_32(file: "trexio_s", ao_1e_int_ecp: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_ecp_32(file, ao_1e_int_ecp)

def trexio_write_ao_1e_int_ecp_32(file: "trexio_s", ao_1e_int_ecp: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_ecp_32(file, ao_1e_int_ecp)

def trexio_read_ao_1e_int_ecp_64(file: "trexio_s", ao_1e_int_ecp: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_ecp_64(file, ao_1e_int_ecp)

def trexio_write_ao_1e_int_ecp_64(file: "trexio_s", ao_1e_int_ecp: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_ecp_64(file, ao_1e_int_ecp)

def trexio_read_safe_ao_1e_int_ecp(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_ecp(file, dset_out)

def trexio_write_safe_ao_1e_int_ecp(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_ecp(file, dset_in)

def trexio_read_safe_ao_1e_int_ecp_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_ecp_32(file, dset_out)

def trexio_write_safe_ao_1e_int_ecp_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_ecp_32(file, dset_in)

def trexio_read_safe_ao_1e_int_ecp_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_ecp_64(file, dset_out)

def trexio_write_safe_ao_1e_int_ecp_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_ecp_64(file, dset_in)

def trexio_has_ao_1e_int_core_hamiltonian(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int_core_hamiltonian(file)

def trexio_read_ao_1e_int_core_hamiltonian(file: "trexio_s", ao_1e_int_core_hamiltonian: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_core_hamiltonian(file, ao_1e_int_core_hamiltonian)

def trexio_write_ao_1e_int_core_hamiltonian(file: "trexio_s", ao_1e_int_core_hamiltonian: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_core_hamiltonian(file, ao_1e_int_core_hamiltonian)

def trexio_read_ao_1e_int_core_hamiltonian_32(file: "trexio_s", ao_1e_int_core_hamiltonian: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_core_hamiltonian_32(file, ao_1e_int_core_hamiltonian)

def trexio_write_ao_1e_int_core_hamiltonian_32(file: "trexio_s", ao_1e_int_core_hamiltonian: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_core_hamiltonian_32(file, ao_1e_int_core_hamiltonian)

def trexio_read_ao_1e_int_core_hamiltonian_64(file: "trexio_s", ao_1e_int_core_hamiltonian: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_core_hamiltonian_64(file, ao_1e_int_core_hamiltonian)

def trexio_write_ao_1e_int_core_hamiltonian_64(file: "trexio_s", ao_1e_int_core_hamiltonian: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_core_hamiltonian_64(file, ao_1e_int_core_hamiltonian)

def trexio_read_safe_ao_1e_int_core_hamiltonian(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_core_hamiltonian(file, dset_out)

def trexio_write_safe_ao_1e_int_core_hamiltonian(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_core_hamiltonian(file, dset_in)

def trexio_read_safe_ao_1e_int_core_hamiltonian_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_core_hamiltonian_32(file, dset_out)

def trexio_write_safe_ao_1e_int_core_hamiltonian_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_core_hamiltonian_32(file, dset_in)

def trexio_read_safe_ao_1e_int_core_hamiltonian_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_core_hamiltonian_64(file, dset_out)

def trexio_write_safe_ao_1e_int_core_hamiltonian_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_core_hamiltonian_64(file, dset_in)

def trexio_has_ao_1e_int_overlap_im(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int_overlap_im(file)

def trexio_read_ao_1e_int_overlap_im(file: "trexio_s", ao_1e_int_overlap_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_overlap_im(file, ao_1e_int_overlap_im)

def trexio_write_ao_1e_int_overlap_im(file: "trexio_s", ao_1e_int_overlap_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_overlap_im(file, ao_1e_int_overlap_im)

def trexio_read_ao_1e_int_overlap_im_32(file: "trexio_s", ao_1e_int_overlap_im: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_overlap_im_32(file, ao_1e_int_overlap_im)

def trexio_write_ao_1e_int_overlap_im_32(file: "trexio_s", ao_1e_int_overlap_im: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_overlap_im_32(file, ao_1e_int_overlap_im)

def trexio_read_ao_1e_int_overlap_im_64(file: "trexio_s", ao_1e_int_overlap_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_overlap_im_64(file, ao_1e_int_overlap_im)

def trexio_write_ao_1e_int_overlap_im_64(file: "trexio_s", ao_1e_int_overlap_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_overlap_im_64(file, ao_1e_int_overlap_im)

def trexio_read_safe_ao_1e_int_overlap_im(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_overlap_im(file, dset_out)

def trexio_write_safe_ao_1e_int_overlap_im(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_overlap_im(file, dset_in)

def trexio_read_safe_ao_1e_int_overlap_im_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_overlap_im_32(file, dset_out)

def trexio_write_safe_ao_1e_int_overlap_im_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_overlap_im_32(file, dset_in)

def trexio_read_safe_ao_1e_int_overlap_im_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_overlap_im_64(file, dset_out)

def trexio_write_safe_ao_1e_int_overlap_im_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_overlap_im_64(file, dset_in)

def trexio_has_ao_1e_int_kinetic_im(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int_kinetic_im(file)

def trexio_read_ao_1e_int_kinetic_im(file: "trexio_s", ao_1e_int_kinetic_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_kinetic_im(file, ao_1e_int_kinetic_im)

def trexio_write_ao_1e_int_kinetic_im(file: "trexio_s", ao_1e_int_kinetic_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_kinetic_im(file, ao_1e_int_kinetic_im)

def trexio_read_ao_1e_int_kinetic_im_32(file: "trexio_s", ao_1e_int_kinetic_im: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_kinetic_im_32(file, ao_1e_int_kinetic_im)

def trexio_write_ao_1e_int_kinetic_im_32(file: "trexio_s", ao_1e_int_kinetic_im: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_kinetic_im_32(file, ao_1e_int_kinetic_im)

def trexio_read_ao_1e_int_kinetic_im_64(file: "trexio_s", ao_1e_int_kinetic_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_kinetic_im_64(file, ao_1e_int_kinetic_im)

def trexio_write_ao_1e_int_kinetic_im_64(file: "trexio_s", ao_1e_int_kinetic_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_kinetic_im_64(file, ao_1e_int_kinetic_im)

def trexio_read_safe_ao_1e_int_kinetic_im(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_kinetic_im(file, dset_out)

def trexio_write_safe_ao_1e_int_kinetic_im(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_kinetic_im(file, dset_in)

def trexio_read_safe_ao_1e_int_kinetic_im_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_kinetic_im_32(file, dset_out)

def trexio_write_safe_ao_1e_int_kinetic_im_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_kinetic_im_32(file, dset_in)

def trexio_read_safe_ao_1e_int_kinetic_im_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_kinetic_im_64(file, dset_out)

def trexio_write_safe_ao_1e_int_kinetic_im_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_kinetic_im_64(file, dset_in)

def trexio_has_ao_1e_int_potential_n_e_im(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int_potential_n_e_im(file)

def trexio_read_ao_1e_int_potential_n_e_im(file: "trexio_s", ao_1e_int_potential_n_e_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_potential_n_e_im(file, ao_1e_int_potential_n_e_im)

def trexio_write_ao_1e_int_potential_n_e_im(file: "trexio_s", ao_1e_int_potential_n_e_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_potential_n_e_im(file, ao_1e_int_potential_n_e_im)

def trexio_read_ao_1e_int_potential_n_e_im_32(file: "trexio_s", ao_1e_int_potential_n_e_im: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_potential_n_e_im_32(file, ao_1e_int_potential_n_e_im)

def trexio_write_ao_1e_int_potential_n_e_im_32(file: "trexio_s", ao_1e_int_potential_n_e_im: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_potential_n_e_im_32(file, ao_1e_int_potential_n_e_im)

def trexio_read_ao_1e_int_potential_n_e_im_64(file: "trexio_s", ao_1e_int_potential_n_e_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_potential_n_e_im_64(file, ao_1e_int_potential_n_e_im)

def trexio_write_ao_1e_int_potential_n_e_im_64(file: "trexio_s", ao_1e_int_potential_n_e_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_potential_n_e_im_64(file, ao_1e_int_potential_n_e_im)

def trexio_read_safe_ao_1e_int_potential_n_e_im(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_potential_n_e_im(file, dset_out)

def trexio_write_safe_ao_1e_int_potential_n_e_im(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_potential_n_e_im(file, dset_in)

def trexio_read_safe_ao_1e_int_potential_n_e_im_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_potential_n_e_im_32(file, dset_out)

def trexio_write_safe_ao_1e_int_potential_n_e_im_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_potential_n_e_im_32(file, dset_in)

def trexio_read_safe_ao_1e_int_potential_n_e_im_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_potential_n_e_im_64(file, dset_out)

def trexio_write_safe_ao_1e_int_potential_n_e_im_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_potential_n_e_im_64(file, dset_in)

def trexio_has_ao_1e_int_ecp_im(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int_ecp_im(file)

def trexio_read_ao_1e_int_ecp_im(file: "trexio_s", ao_1e_int_ecp_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_ecp_im(file, ao_1e_int_ecp_im)

def trexio_write_ao_1e_int_ecp_im(file: "trexio_s", ao_1e_int_ecp_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_ecp_im(file, ao_1e_int_ecp_im)

def trexio_read_ao_1e_int_ecp_im_32(file: "trexio_s", ao_1e_int_ecp_im: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_ecp_im_32(file, ao_1e_int_ecp_im)

def trexio_write_ao_1e_int_ecp_im_32(file: "trexio_s", ao_1e_int_ecp_im: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_ecp_im_32(file, ao_1e_int_ecp_im)

def trexio_read_ao_1e_int_ecp_im_64(file: "trexio_s", ao_1e_int_ecp_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_ecp_im_64(file, ao_1e_int_ecp_im)

def trexio_write_ao_1e_int_ecp_im_64(file: "trexio_s", ao_1e_int_ecp_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_ecp_im_64(file, ao_1e_int_ecp_im)

def trexio_read_safe_ao_1e_int_ecp_im(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_ecp_im(file, dset_out)

def trexio_write_safe_ao_1e_int_ecp_im(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_ecp_im(file, dset_in)

def trexio_read_safe_ao_1e_int_ecp_im_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_ecp_im_32(file, dset_out)

def trexio_write_safe_ao_1e_int_ecp_im_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_ecp_im_32(file, dset_in)

def trexio_read_safe_ao_1e_int_ecp_im_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_ecp_im_64(file, dset_out)

def trexio_write_safe_ao_1e_int_ecp_im_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_ecp_im_64(file, dset_in)

def trexio_has_ao_1e_int_core_hamiltonian_im(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int_core_hamiltonian_im(file)

def trexio_read_ao_1e_int_core_hamiltonian_im(file: "trexio_s", ao_1e_int_core_hamiltonian_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_core_hamiltonian_im(file, ao_1e_int_core_hamiltonian_im)

def trexio_write_ao_1e_int_core_hamiltonian_im(file: "trexio_s", ao_1e_int_core_hamiltonian_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_core_hamiltonian_im(file, ao_1e_int_core_hamiltonian_im)

def trexio_read_ao_1e_int_core_hamiltonian_im_32(file: "trexio_s", ao_1e_int_core_hamiltonian_im: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_core_hamiltonian_im_32(file, ao_1e_int_core_hamiltonian_im)

def trexio_write_ao_1e_int_core_hamiltonian_im_32(file: "trexio_s", ao_1e_int_core_hamiltonian_im: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_core_hamiltonian_im_32(file, ao_1e_int_core_hamiltonian_im)

def trexio_read_ao_1e_int_core_hamiltonian_im_64(file: "trexio_s", ao_1e_int_core_hamiltonian_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_1e_int_core_hamiltonian_im_64(file, ao_1e_int_core_hamiltonian_im)

def trexio_write_ao_1e_int_core_hamiltonian_im_64(file: "trexio_s", ao_1e_int_core_hamiltonian_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_1e_int_core_hamiltonian_im_64(file, ao_1e_int_core_hamiltonian_im)

def trexio_read_safe_ao_1e_int_core_hamiltonian_im(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_core_hamiltonian_im(file, dset_out)

def trexio_write_safe_ao_1e_int_core_hamiltonian_im(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_core_hamiltonian_im(file, dset_in)

def trexio_read_safe_ao_1e_int_core_hamiltonian_im_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_core_hamiltonian_im_32(file, dset_out)

def trexio_write_safe_ao_1e_int_core_hamiltonian_im_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_core_hamiltonian_im_32(file, dset_in)

def trexio_read_safe_ao_1e_int_core_hamiltonian_im_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_ao_1e_int_core_hamiltonian_im_64(file, dset_out)

def trexio_write_safe_ao_1e_int_core_hamiltonian_im_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_core_hamiltonian_im_64(file, dset_in)

def trexio_has_mo_coefficient(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_coefficient(file)

def trexio_read_mo_coefficient(file: "trexio_s", mo_coefficient: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_coefficient(file, mo_coefficient)

def trexio_write_mo_coefficient(file: "trexio_s", mo_coefficient: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_coefficient(file, mo_coefficient)

def trexio_read_mo_coefficient_32(file: "trexio_s", mo_coefficient: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_coefficient_32(file, mo_coefficient)

def trexio_write_mo_coefficient_32(file: "trexio_s", mo_coefficient: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_coefficient_32(file, mo_coefficient)

def trexio_read_mo_coefficient_64(file: "trexio_s", mo_coefficient: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_coefficient_64(file, mo_coefficient)

def trexio_write_mo_coefficient_64(file: "trexio_s", mo_coefficient: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_coefficient_64(file, mo_coefficient)

def trexio_read_safe_mo_coefficient(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_coefficient(file, dset_out)

def trexio_write_safe_mo_coefficient(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_coefficient(file, dset_in)

def trexio_read_safe_mo_coefficient_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_coefficient_32(file, dset_out)

def trexio_write_safe_mo_coefficient_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_coefficient_32(file, dset_in)

def trexio_read_safe_mo_coefficient_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_coefficient_64(file, dset_out)

def trexio_write_safe_mo_coefficient_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_coefficient_64(file, dset_in)

def trexio_has_mo_coefficient_im(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_coefficient_im(file)

def trexio_read_mo_coefficient_im(file: "trexio_s", mo_coefficient_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_coefficient_im(file, mo_coefficient_im)

def trexio_write_mo_coefficient_im(file: "trexio_s", mo_coefficient_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_coefficient_im(file, mo_coefficient_im)

def trexio_read_mo_coefficient_im_32(file: "trexio_s", mo_coefficient_im: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_coefficient_im_32(file, mo_coefficient_im)

def trexio_write_mo_coefficient_im_32(file: "trexio_s", mo_coefficient_im: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_coefficient_im_32(file, mo_coefficient_im)

def trexio_read_mo_coefficient_im_64(file: "trexio_s", mo_coefficient_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_coefficient_im_64(file, mo_coefficient_im)

def trexio_write_mo_coefficient_im_64(file: "trexio_s", mo_coefficient_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_coefficient_im_64(file, mo_coefficient_im)

def trexio_read_safe_mo_coefficient_im(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_coefficient_im(file, dset_out)

def trexio_write_safe_mo_coefficient_im(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_coefficient_im(file, dset_in)

def trexio_read_safe_mo_coefficient_im_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_coefficient_im_32(file, dset_out)

def trexio_write_safe_mo_coefficient_im_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_coefficient_im_32(file, dset_in)

def trexio_read_safe_mo_coefficient_im_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_coefficient_im_64(file, dset_out)

def trexio_write_safe_mo_coefficient_im_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_coefficient_im_64(file, dset_in)

def trexio_has_mo_occupation(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_occupation(file)

def trexio_read_mo_occupation(file: "trexio_s", mo_occupation: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_occupation(file, mo_occupation)

def trexio_write_mo_occupation(file: "trexio_s", mo_occupation: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_occupation(file, mo_occupation)

def trexio_read_mo_occupation_32(file: "trexio_s", mo_occupation: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_occupation_32(file, mo_occupation)

def trexio_write_mo_occupation_32(file: "trexio_s", mo_occupation: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_occupation_32(file, mo_occupation)

def trexio_read_mo_occupation_64(file: "trexio_s", mo_occupation: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_occupation_64(file, mo_occupation)

def trexio_write_mo_occupation_64(file: "trexio_s", mo_occupation: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_occupation_64(file, mo_occupation)

def trexio_read_safe_mo_occupation(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_occupation(file, dset_out)

def trexio_write_safe_mo_occupation(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_occupation(file, dset_in)

def trexio_read_safe_mo_occupation_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_occupation_32(file, dset_out)

def trexio_write_safe_mo_occupation_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_occupation_32(file, dset_in)

def trexio_read_safe_mo_occupation_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_occupation_64(file, dset_out)

def trexio_write_safe_mo_occupation_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_occupation_64(file, dset_in)

def trexio_has_mo_energy(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_energy(file)

def trexio_read_mo_energy(file: "trexio_s", mo_energy: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_energy(file, mo_energy)

def trexio_write_mo_energy(file: "trexio_s", mo_energy: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_energy(file, mo_energy)

def trexio_read_mo_energy_32(file: "trexio_s", mo_energy: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_energy_32(file, mo_energy)

def trexio_write_mo_energy_32(file: "trexio_s", mo_energy: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_energy_32(file, mo_energy)

def trexio_read_mo_energy_64(file: "trexio_s", mo_energy: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_energy_64(file, mo_energy)

def trexio_write_mo_energy_64(file: "trexio_s", mo_energy: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_energy_64(file, mo_energy)

def trexio_read_safe_mo_energy(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_energy(file, dset_out)

def trexio_write_safe_mo_energy(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_energy(file, dset_in)

def trexio_read_safe_mo_energy_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_energy_32(file, dset_out)

def trexio_write_safe_mo_energy_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_energy_32(file, dset_in)

def trexio_read_safe_mo_energy_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_energy_64(file, dset_out)

def trexio_write_safe_mo_energy_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_energy_64(file, dset_in)

def trexio_has_mo_spin(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_spin(file)

def trexio_read_mo_spin(file: "trexio_s", mo_spin: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_spin(file, mo_spin)

def trexio_write_mo_spin(file: "trexio_s", mo_spin: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_spin(file, mo_spin)

def trexio_read_mo_spin_32(file: "trexio_s", mo_spin: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_spin_32(file, mo_spin)

def trexio_write_mo_spin_32(file: "trexio_s", mo_spin: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_spin_32(file, mo_spin)

def trexio_read_mo_spin_64(file: "trexio_s", mo_spin: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_spin_64(file, mo_spin)

def trexio_write_mo_spin_64(file: "trexio_s", mo_spin: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_spin_64(file, mo_spin)

def trexio_read_safe_mo_spin(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_spin(file, dset_out)

def trexio_write_safe_mo_spin(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_spin(file, dset_in)

def trexio_read_safe_mo_spin_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_spin_32(file, dset_out)

def trexio_write_safe_mo_spin_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_spin_32(file, dset_in)

def trexio_read_safe_mo_spin_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_spin_64(file, dset_out)

def trexio_write_safe_mo_spin_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_spin_64(file, dset_in)

def trexio_has_mo_1e_int_overlap(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int_overlap(file)

def trexio_read_mo_1e_int_overlap(file: "trexio_s", mo_1e_int_overlap: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_overlap(file, mo_1e_int_overlap)

def trexio_write_mo_1e_int_overlap(file: "trexio_s", mo_1e_int_overlap: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_overlap(file, mo_1e_int_overlap)

def trexio_read_mo_1e_int_overlap_32(file: "trexio_s", mo_1e_int_overlap: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_overlap_32(file, mo_1e_int_overlap)

def trexio_write_mo_1e_int_overlap_32(file: "trexio_s", mo_1e_int_overlap: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_overlap_32(file, mo_1e_int_overlap)

def trexio_read_mo_1e_int_overlap_64(file: "trexio_s", mo_1e_int_overlap: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_overlap_64(file, mo_1e_int_overlap)

def trexio_write_mo_1e_int_overlap_64(file: "trexio_s", mo_1e_int_overlap: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_overlap_64(file, mo_1e_int_overlap)

def trexio_read_safe_mo_1e_int_overlap(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_overlap(file, dset_out)

def trexio_write_safe_mo_1e_int_overlap(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_overlap(file, dset_in)

def trexio_read_safe_mo_1e_int_overlap_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_overlap_32(file, dset_out)

def trexio_write_safe_mo_1e_int_overlap_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_overlap_32(file, dset_in)

def trexio_read_safe_mo_1e_int_overlap_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_overlap_64(file, dset_out)

def trexio_write_safe_mo_1e_int_overlap_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_overlap_64(file, dset_in)

def trexio_has_mo_1e_int_kinetic(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int_kinetic(file)

def trexio_read_mo_1e_int_kinetic(file: "trexio_s", mo_1e_int_kinetic: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_kinetic(file, mo_1e_int_kinetic)

def trexio_write_mo_1e_int_kinetic(file: "trexio_s", mo_1e_int_kinetic: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_kinetic(file, mo_1e_int_kinetic)

def trexio_read_mo_1e_int_kinetic_32(file: "trexio_s", mo_1e_int_kinetic: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_kinetic_32(file, mo_1e_int_kinetic)

def trexio_write_mo_1e_int_kinetic_32(file: "trexio_s", mo_1e_int_kinetic: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_kinetic_32(file, mo_1e_int_kinetic)

def trexio_read_mo_1e_int_kinetic_64(file: "trexio_s", mo_1e_int_kinetic: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_kinetic_64(file, mo_1e_int_kinetic)

def trexio_write_mo_1e_int_kinetic_64(file: "trexio_s", mo_1e_int_kinetic: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_kinetic_64(file, mo_1e_int_kinetic)

def trexio_read_safe_mo_1e_int_kinetic(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_kinetic(file, dset_out)

def trexio_write_safe_mo_1e_int_kinetic(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_kinetic(file, dset_in)

def trexio_read_safe_mo_1e_int_kinetic_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_kinetic_32(file, dset_out)

def trexio_write_safe_mo_1e_int_kinetic_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_kinetic_32(file, dset_in)

def trexio_read_safe_mo_1e_int_kinetic_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_kinetic_64(file, dset_out)

def trexio_write_safe_mo_1e_int_kinetic_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_kinetic_64(file, dset_in)

def trexio_has_mo_1e_int_potential_n_e(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int_potential_n_e(file)

def trexio_read_mo_1e_int_potential_n_e(file: "trexio_s", mo_1e_int_potential_n_e: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_potential_n_e(file, mo_1e_int_potential_n_e)

def trexio_write_mo_1e_int_potential_n_e(file: "trexio_s", mo_1e_int_potential_n_e: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_potential_n_e(file, mo_1e_int_potential_n_e)

def trexio_read_mo_1e_int_potential_n_e_32(file: "trexio_s", mo_1e_int_potential_n_e: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_potential_n_e_32(file, mo_1e_int_potential_n_e)

def trexio_write_mo_1e_int_potential_n_e_32(file: "trexio_s", mo_1e_int_potential_n_e: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_potential_n_e_32(file, mo_1e_int_potential_n_e)

def trexio_read_mo_1e_int_potential_n_e_64(file: "trexio_s", mo_1e_int_potential_n_e: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_potential_n_e_64(file, mo_1e_int_potential_n_e)

def trexio_write_mo_1e_int_potential_n_e_64(file: "trexio_s", mo_1e_int_potential_n_e: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_potential_n_e_64(file, mo_1e_int_potential_n_e)

def trexio_read_safe_mo_1e_int_potential_n_e(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_potential_n_e(file, dset_out)

def trexio_write_safe_mo_1e_int_potential_n_e(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_potential_n_e(file, dset_in)

def trexio_read_safe_mo_1e_int_potential_n_e_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_potential_n_e_32(file, dset_out)

def trexio_write_safe_mo_1e_int_potential_n_e_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_potential_n_e_32(file, dset_in)

def trexio_read_safe_mo_1e_int_potential_n_e_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_potential_n_e_64(file, dset_out)

def trexio_write_safe_mo_1e_int_potential_n_e_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_potential_n_e_64(file, dset_in)

def trexio_has_mo_1e_int_ecp(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int_ecp(file)

def trexio_read_mo_1e_int_ecp(file: "trexio_s", mo_1e_int_ecp: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_ecp(file, mo_1e_int_ecp)

def trexio_write_mo_1e_int_ecp(file: "trexio_s", mo_1e_int_ecp: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_ecp(file, mo_1e_int_ecp)

def trexio_read_mo_1e_int_ecp_32(file: "trexio_s", mo_1e_int_ecp: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_ecp_32(file, mo_1e_int_ecp)

def trexio_write_mo_1e_int_ecp_32(file: "trexio_s", mo_1e_int_ecp: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_ecp_32(file, mo_1e_int_ecp)

def trexio_read_mo_1e_int_ecp_64(file: "trexio_s", mo_1e_int_ecp: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_ecp_64(file, mo_1e_int_ecp)

def trexio_write_mo_1e_int_ecp_64(file: "trexio_s", mo_1e_int_ecp: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_ecp_64(file, mo_1e_int_ecp)

def trexio_read_safe_mo_1e_int_ecp(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_ecp(file, dset_out)

def trexio_write_safe_mo_1e_int_ecp(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_ecp(file, dset_in)

def trexio_read_safe_mo_1e_int_ecp_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_ecp_32(file, dset_out)

def trexio_write_safe_mo_1e_int_ecp_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_ecp_32(file, dset_in)

def trexio_read_safe_mo_1e_int_ecp_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_ecp_64(file, dset_out)

def trexio_write_safe_mo_1e_int_ecp_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_ecp_64(file, dset_in)

def trexio_has_mo_1e_int_core_hamiltonian(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int_core_hamiltonian(file)

def trexio_read_mo_1e_int_core_hamiltonian(file: "trexio_s", mo_1e_int_core_hamiltonian: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_core_hamiltonian(file, mo_1e_int_core_hamiltonian)

def trexio_write_mo_1e_int_core_hamiltonian(file: "trexio_s", mo_1e_int_core_hamiltonian: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_core_hamiltonian(file, mo_1e_int_core_hamiltonian)

def trexio_read_mo_1e_int_core_hamiltonian_32(file: "trexio_s", mo_1e_int_core_hamiltonian: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_core_hamiltonian_32(file, mo_1e_int_core_hamiltonian)

def trexio_write_mo_1e_int_core_hamiltonian_32(file: "trexio_s", mo_1e_int_core_hamiltonian: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_core_hamiltonian_32(file, mo_1e_int_core_hamiltonian)

def trexio_read_mo_1e_int_core_hamiltonian_64(file: "trexio_s", mo_1e_int_core_hamiltonian: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_core_hamiltonian_64(file, mo_1e_int_core_hamiltonian)

def trexio_write_mo_1e_int_core_hamiltonian_64(file: "trexio_s", mo_1e_int_core_hamiltonian: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_core_hamiltonian_64(file, mo_1e_int_core_hamiltonian)

def trexio_read_safe_mo_1e_int_core_hamiltonian(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_core_hamiltonian(file, dset_out)

def trexio_write_safe_mo_1e_int_core_hamiltonian(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_core_hamiltonian(file, dset_in)

def trexio_read_safe_mo_1e_int_core_hamiltonian_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_core_hamiltonian_32(file, dset_out)

def trexio_write_safe_mo_1e_int_core_hamiltonian_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_core_hamiltonian_32(file, dset_in)

def trexio_read_safe_mo_1e_int_core_hamiltonian_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_core_hamiltonian_64(file, dset_out)

def trexio_write_safe_mo_1e_int_core_hamiltonian_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_core_hamiltonian_64(file, dset_in)

def trexio_has_mo_1e_int_overlap_im(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int_overlap_im(file)

def trexio_read_mo_1e_int_overlap_im(file: "trexio_s", mo_1e_int_overlap_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_overlap_im(file, mo_1e_int_overlap_im)

def trexio_write_mo_1e_int_overlap_im(file: "trexio_s", mo_1e_int_overlap_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_overlap_im(file, mo_1e_int_overlap_im)

def trexio_read_mo_1e_int_overlap_im_32(file: "trexio_s", mo_1e_int_overlap_im: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_overlap_im_32(file, mo_1e_int_overlap_im)

def trexio_write_mo_1e_int_overlap_im_32(file: "trexio_s", mo_1e_int_overlap_im: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_overlap_im_32(file, mo_1e_int_overlap_im)

def trexio_read_mo_1e_int_overlap_im_64(file: "trexio_s", mo_1e_int_overlap_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_overlap_im_64(file, mo_1e_int_overlap_im)

def trexio_write_mo_1e_int_overlap_im_64(file: "trexio_s", mo_1e_int_overlap_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_overlap_im_64(file, mo_1e_int_overlap_im)

def trexio_read_safe_mo_1e_int_overlap_im(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_overlap_im(file, dset_out)

def trexio_write_safe_mo_1e_int_overlap_im(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_overlap_im(file, dset_in)

def trexio_read_safe_mo_1e_int_overlap_im_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_overlap_im_32(file, dset_out)

def trexio_write_safe_mo_1e_int_overlap_im_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_overlap_im_32(file, dset_in)

def trexio_read_safe_mo_1e_int_overlap_im_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_overlap_im_64(file, dset_out)

def trexio_write_safe_mo_1e_int_overlap_im_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_overlap_im_64(file, dset_in)

def trexio_has_mo_1e_int_kinetic_im(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int_kinetic_im(file)

def trexio_read_mo_1e_int_kinetic_im(file: "trexio_s", mo_1e_int_kinetic_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_kinetic_im(file, mo_1e_int_kinetic_im)

def trexio_write_mo_1e_int_kinetic_im(file: "trexio_s", mo_1e_int_kinetic_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_kinetic_im(file, mo_1e_int_kinetic_im)

def trexio_read_mo_1e_int_kinetic_im_32(file: "trexio_s", mo_1e_int_kinetic_im: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_kinetic_im_32(file, mo_1e_int_kinetic_im)

def trexio_write_mo_1e_int_kinetic_im_32(file: "trexio_s", mo_1e_int_kinetic_im: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_kinetic_im_32(file, mo_1e_int_kinetic_im)

def trexio_read_mo_1e_int_kinetic_im_64(file: "trexio_s", mo_1e_int_kinetic_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_kinetic_im_64(file, mo_1e_int_kinetic_im)

def trexio_write_mo_1e_int_kinetic_im_64(file: "trexio_s", mo_1e_int_kinetic_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_kinetic_im_64(file, mo_1e_int_kinetic_im)

def trexio_read_safe_mo_1e_int_kinetic_im(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_kinetic_im(file, dset_out)

def trexio_write_safe_mo_1e_int_kinetic_im(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_kinetic_im(file, dset_in)

def trexio_read_safe_mo_1e_int_kinetic_im_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_kinetic_im_32(file, dset_out)

def trexio_write_safe_mo_1e_int_kinetic_im_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_kinetic_im_32(file, dset_in)

def trexio_read_safe_mo_1e_int_kinetic_im_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_kinetic_im_64(file, dset_out)

def trexio_write_safe_mo_1e_int_kinetic_im_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_kinetic_im_64(file, dset_in)

def trexio_has_mo_1e_int_potential_n_e_im(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int_potential_n_e_im(file)

def trexio_read_mo_1e_int_potential_n_e_im(file: "trexio_s", mo_1e_int_potential_n_e_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_potential_n_e_im(file, mo_1e_int_potential_n_e_im)

def trexio_write_mo_1e_int_potential_n_e_im(file: "trexio_s", mo_1e_int_potential_n_e_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_potential_n_e_im(file, mo_1e_int_potential_n_e_im)

def trexio_read_mo_1e_int_potential_n_e_im_32(file: "trexio_s", mo_1e_int_potential_n_e_im: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_potential_n_e_im_32(file, mo_1e_int_potential_n_e_im)

def trexio_write_mo_1e_int_potential_n_e_im_32(file: "trexio_s", mo_1e_int_potential_n_e_im: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_potential_n_e_im_32(file, mo_1e_int_potential_n_e_im)

def trexio_read_mo_1e_int_potential_n_e_im_64(file: "trexio_s", mo_1e_int_potential_n_e_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_potential_n_e_im_64(file, mo_1e_int_potential_n_e_im)

def trexio_write_mo_1e_int_potential_n_e_im_64(file: "trexio_s", mo_1e_int_potential_n_e_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_potential_n_e_im_64(file, mo_1e_int_potential_n_e_im)

def trexio_read_safe_mo_1e_int_potential_n_e_im(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_potential_n_e_im(file, dset_out)

def trexio_write_safe_mo_1e_int_potential_n_e_im(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_potential_n_e_im(file, dset_in)

def trexio_read_safe_mo_1e_int_potential_n_e_im_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_potential_n_e_im_32(file, dset_out)

def trexio_write_safe_mo_1e_int_potential_n_e_im_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_potential_n_e_im_32(file, dset_in)

def trexio_read_safe_mo_1e_int_potential_n_e_im_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_potential_n_e_im_64(file, dset_out)

def trexio_write_safe_mo_1e_int_potential_n_e_im_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_potential_n_e_im_64(file, dset_in)

def trexio_has_mo_1e_int_ecp_im(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int_ecp_im(file)

def trexio_read_mo_1e_int_ecp_im(file: "trexio_s", mo_1e_int_ecp_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_ecp_im(file, mo_1e_int_ecp_im)

def trexio_write_mo_1e_int_ecp_im(file: "trexio_s", mo_1e_int_ecp_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_ecp_im(file, mo_1e_int_ecp_im)

def trexio_read_mo_1e_int_ecp_im_32(file: "trexio_s", mo_1e_int_ecp_im: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_ecp_im_32(file, mo_1e_int_ecp_im)

def trexio_write_mo_1e_int_ecp_im_32(file: "trexio_s", mo_1e_int_ecp_im: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_ecp_im_32(file, mo_1e_int_ecp_im)

def trexio_read_mo_1e_int_ecp_im_64(file: "trexio_s", mo_1e_int_ecp_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_ecp_im_64(file, mo_1e_int_ecp_im)

def trexio_write_mo_1e_int_ecp_im_64(file: "trexio_s", mo_1e_int_ecp_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_ecp_im_64(file, mo_1e_int_ecp_im)

def trexio_read_safe_mo_1e_int_ecp_im(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_ecp_im(file, dset_out)

def trexio_write_safe_mo_1e_int_ecp_im(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_ecp_im(file, dset_in)

def trexio_read_safe_mo_1e_int_ecp_im_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_ecp_im_32(file, dset_out)

def trexio_write_safe_mo_1e_int_ecp_im_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_ecp_im_32(file, dset_in)

def trexio_read_safe_mo_1e_int_ecp_im_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_ecp_im_64(file, dset_out)

def trexio_write_safe_mo_1e_int_ecp_im_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_ecp_im_64(file, dset_in)

def trexio_has_mo_1e_int_core_hamiltonian_im(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int_core_hamiltonian_im(file)

def trexio_read_mo_1e_int_core_hamiltonian_im(file: "trexio_s", mo_1e_int_core_hamiltonian_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_core_hamiltonian_im(file, mo_1e_int_core_hamiltonian_im)

def trexio_write_mo_1e_int_core_hamiltonian_im(file: "trexio_s", mo_1e_int_core_hamiltonian_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_core_hamiltonian_im(file, mo_1e_int_core_hamiltonian_im)

def trexio_read_mo_1e_int_core_hamiltonian_im_32(file: "trexio_s", mo_1e_int_core_hamiltonian_im: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_core_hamiltonian_im_32(file, mo_1e_int_core_hamiltonian_im)

def trexio_write_mo_1e_int_core_hamiltonian_im_32(file: "trexio_s", mo_1e_int_core_hamiltonian_im: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_core_hamiltonian_im_32(file, mo_1e_int_core_hamiltonian_im)

def trexio_read_mo_1e_int_core_hamiltonian_im_64(file: "trexio_s", mo_1e_int_core_hamiltonian_im: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_1e_int_core_hamiltonian_im_64(file, mo_1e_int_core_hamiltonian_im)

def trexio_write_mo_1e_int_core_hamiltonian_im_64(file: "trexio_s", mo_1e_int_core_hamiltonian_im: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_1e_int_core_hamiltonian_im_64(file, mo_1e_int_core_hamiltonian_im)

def trexio_read_safe_mo_1e_int_core_hamiltonian_im(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_core_hamiltonian_im(file, dset_out)

def trexio_write_safe_mo_1e_int_core_hamiltonian_im(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_core_hamiltonian_im(file, dset_in)

def trexio_read_safe_mo_1e_int_core_hamiltonian_im_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_core_hamiltonian_im_32(file, dset_out)

def trexio_write_safe_mo_1e_int_core_hamiltonian_im_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_core_hamiltonian_im_32(file, dset_in)

def trexio_read_safe_mo_1e_int_core_hamiltonian_im_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_mo_1e_int_core_hamiltonian_im_64(file, dset_out)

def trexio_write_safe_mo_1e_int_core_hamiltonian_im_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_core_hamiltonian_im_64(file, dset_in)

def trexio_has_rdm_1e(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_1e(file)

def trexio_read_rdm_1e(file: "trexio_s", rdm_1e: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_1e(file, rdm_1e)

def trexio_write_rdm_1e(file: "trexio_s", rdm_1e: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_1e(file, rdm_1e)

def trexio_read_rdm_1e_32(file: "trexio_s", rdm_1e: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_1e_32(file, rdm_1e)

def trexio_write_rdm_1e_32(file: "trexio_s", rdm_1e: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_1e_32(file, rdm_1e)

def trexio_read_rdm_1e_64(file: "trexio_s", rdm_1e: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_1e_64(file, rdm_1e)

def trexio_write_rdm_1e_64(file: "trexio_s", rdm_1e: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_1e_64(file, rdm_1e)

def trexio_read_safe_rdm_1e(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_rdm_1e(file, dset_out)

def trexio_write_safe_rdm_1e(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_1e(file, dset_in)

def trexio_read_safe_rdm_1e_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_rdm_1e_32(file, dset_out)

def trexio_write_safe_rdm_1e_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_1e_32(file, dset_in)

def trexio_read_safe_rdm_1e_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_rdm_1e_64(file, dset_out)

def trexio_write_safe_rdm_1e_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_1e_64(file, dset_in)

def trexio_has_rdm_1e_up(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_1e_up(file)

def trexio_read_rdm_1e_up(file: "trexio_s", rdm_1e_up: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_1e_up(file, rdm_1e_up)

def trexio_write_rdm_1e_up(file: "trexio_s", rdm_1e_up: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_1e_up(file, rdm_1e_up)

def trexio_read_rdm_1e_up_32(file: "trexio_s", rdm_1e_up: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_1e_up_32(file, rdm_1e_up)

def trexio_write_rdm_1e_up_32(file: "trexio_s", rdm_1e_up: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_1e_up_32(file, rdm_1e_up)

def trexio_read_rdm_1e_up_64(file: "trexio_s", rdm_1e_up: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_1e_up_64(file, rdm_1e_up)

def trexio_write_rdm_1e_up_64(file: "trexio_s", rdm_1e_up: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_1e_up_64(file, rdm_1e_up)

def trexio_read_safe_rdm_1e_up(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_rdm_1e_up(file, dset_out)

def trexio_write_safe_rdm_1e_up(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_1e_up(file, dset_in)

def trexio_read_safe_rdm_1e_up_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_rdm_1e_up_32(file, dset_out)

def trexio_write_safe_rdm_1e_up_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_1e_up_32(file, dset_in)

def trexio_read_safe_rdm_1e_up_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_rdm_1e_up_64(file, dset_out)

def trexio_write_safe_rdm_1e_up_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_1e_up_64(file, dset_in)

def trexio_has_rdm_1e_dn(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_1e_dn(file)

def trexio_read_rdm_1e_dn(file: "trexio_s", rdm_1e_dn: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_1e_dn(file, rdm_1e_dn)

def trexio_write_rdm_1e_dn(file: "trexio_s", rdm_1e_dn: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_1e_dn(file, rdm_1e_dn)

def trexio_read_rdm_1e_dn_32(file: "trexio_s", rdm_1e_dn: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_1e_dn_32(file, rdm_1e_dn)

def trexio_write_rdm_1e_dn_32(file: "trexio_s", rdm_1e_dn: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_1e_dn_32(file, rdm_1e_dn)

def trexio_read_rdm_1e_dn_64(file: "trexio_s", rdm_1e_dn: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_1e_dn_64(file, rdm_1e_dn)

def trexio_write_rdm_1e_dn_64(file: "trexio_s", rdm_1e_dn: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_1e_dn_64(file, rdm_1e_dn)

def trexio_read_safe_rdm_1e_dn(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_rdm_1e_dn(file, dset_out)

def trexio_write_safe_rdm_1e_dn(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_1e_dn(file, dset_in)

def trexio_read_safe_rdm_1e_dn_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_rdm_1e_dn_32(file, dset_out)

def trexio_write_safe_rdm_1e_dn_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_1e_dn_32(file, dset_in)

def trexio_read_safe_rdm_1e_dn_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_rdm_1e_dn_64(file, dset_out)

def trexio_write_safe_rdm_1e_dn_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_1e_dn_64(file, dset_in)

def trexio_has_jastrow_en(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow_en(file)

def trexio_read_jastrow_en(file: "trexio_s", jastrow_en: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_en(file, jastrow_en)

def trexio_write_jastrow_en(file: "trexio_s", jastrow_en: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en(file, jastrow_en)

def trexio_read_jastrow_en_32(file: "trexio_s", jastrow_en: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_en_32(file, jastrow_en)

def trexio_write_jastrow_en_32(file: "trexio_s", jastrow_en: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en_32(file, jastrow_en)

def trexio_read_jastrow_en_64(file: "trexio_s", jastrow_en: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_en_64(file, jastrow_en)

def trexio_write_jastrow_en_64(file: "trexio_s", jastrow_en: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en_64(file, jastrow_en)

def trexio_read_safe_jastrow_en(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_en(file, dset_out)

def trexio_write_safe_jastrow_en(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_en(file, dset_in)

def trexio_read_safe_jastrow_en_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_en_32(file, dset_out)

def trexio_write_safe_jastrow_en_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_en_32(file, dset_in)

def trexio_read_safe_jastrow_en_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_en_64(file, dset_out)

def trexio_write_safe_jastrow_en_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_en_64(file, dset_in)

def trexio_has_jastrow_ee(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow_ee(file)

def trexio_read_jastrow_ee(file: "trexio_s", jastrow_ee: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_ee(file, jastrow_ee)

def trexio_write_jastrow_ee(file: "trexio_s", jastrow_ee: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_ee(file, jastrow_ee)

def trexio_read_jastrow_ee_32(file: "trexio_s", jastrow_ee: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_ee_32(file, jastrow_ee)

def trexio_write_jastrow_ee_32(file: "trexio_s", jastrow_ee: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_ee_32(file, jastrow_ee)

def trexio_read_jastrow_ee_64(file: "trexio_s", jastrow_ee: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_ee_64(file, jastrow_ee)

def trexio_write_jastrow_ee_64(file: "trexio_s", jastrow_ee: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_ee_64(file, jastrow_ee)

def trexio_read_safe_jastrow_ee(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_ee(file, dset_out)

def trexio_write_safe_jastrow_ee(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_ee(file, dset_in)

def trexio_read_safe_jastrow_ee_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_ee_32(file, dset_out)

def trexio_write_safe_jastrow_ee_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_ee_32(file, dset_in)

def trexio_read_safe_jastrow_ee_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_ee_64(file, dset_out)

def trexio_write_safe_jastrow_ee_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_ee_64(file, dset_in)

def trexio_has_jastrow_een(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow_een(file)

def trexio_read_jastrow_een(file: "trexio_s", jastrow_een: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_een(file, jastrow_een)

def trexio_write_jastrow_een(file: "trexio_s", jastrow_een: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_een(file, jastrow_een)

def trexio_read_jastrow_een_32(file: "trexio_s", jastrow_een: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_een_32(file, jastrow_een)

def trexio_write_jastrow_een_32(file: "trexio_s", jastrow_een: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_een_32(file, jastrow_een)

def trexio_read_jastrow_een_64(file: "trexio_s", jastrow_een: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_een_64(file, jastrow_een)

def trexio_write_jastrow_een_64(file: "trexio_s", jastrow_een: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_een_64(file, jastrow_een)

def trexio_read_safe_jastrow_een(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_een(file, dset_out)

def trexio_write_safe_jastrow_een(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_een(file, dset_in)

def trexio_read_safe_jastrow_een_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_een_32(file, dset_out)

def trexio_write_safe_jastrow_een_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_een_32(file, dset_in)

def trexio_read_safe_jastrow_een_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_een_64(file, dset_out)

def trexio_write_safe_jastrow_een_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_een_64(file, dset_in)

def trexio_has_jastrow_en_nucleus(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow_en_nucleus(file)

def trexio_read_jastrow_en_nucleus(file: "trexio_s", jastrow_en_nucleus: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_en_nucleus(file, jastrow_en_nucleus)

def trexio_write_jastrow_en_nucleus(file: "trexio_s", jastrow_en_nucleus: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en_nucleus(file, jastrow_en_nucleus)

def trexio_read_jastrow_en_nucleus_32(file: "trexio_s", jastrow_en_nucleus: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_en_nucleus_32(file, jastrow_en_nucleus)

def trexio_write_jastrow_en_nucleus_32(file: "trexio_s", jastrow_en_nucleus: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en_nucleus_32(file, jastrow_en_nucleus)

def trexio_read_jastrow_en_nucleus_64(file: "trexio_s", jastrow_en_nucleus: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_en_nucleus_64(file, jastrow_en_nucleus)

def trexio_write_jastrow_en_nucleus_64(file: "trexio_s", jastrow_en_nucleus: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en_nucleus_64(file, jastrow_en_nucleus)

def trexio_read_safe_jastrow_en_nucleus(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_en_nucleus(file, dset_out)

def trexio_write_safe_jastrow_en_nucleus(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_en_nucleus(file, dset_in)

def trexio_read_safe_jastrow_en_nucleus_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_en_nucleus_32(file, dset_out)

def trexio_write_safe_jastrow_en_nucleus_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_en_nucleus_32(file, dset_in)

def trexio_read_safe_jastrow_en_nucleus_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_en_nucleus_64(file, dset_out)

def trexio_write_safe_jastrow_en_nucleus_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_en_nucleus_64(file, dset_in)

def trexio_has_jastrow_een_nucleus(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow_een_nucleus(file)

def trexio_read_jastrow_een_nucleus(file: "trexio_s", jastrow_een_nucleus: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_een_nucleus(file, jastrow_een_nucleus)

def trexio_write_jastrow_een_nucleus(file: "trexio_s", jastrow_een_nucleus: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_een_nucleus(file, jastrow_een_nucleus)

def trexio_read_jastrow_een_nucleus_32(file: "trexio_s", jastrow_een_nucleus: "int32_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_een_nucleus_32(file, jastrow_een_nucleus)

def trexio_write_jastrow_een_nucleus_32(file: "trexio_s", jastrow_een_nucleus: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_een_nucleus_32(file, jastrow_een_nucleus)

def trexio_read_jastrow_een_nucleus_64(file: "trexio_s", jastrow_een_nucleus: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_een_nucleus_64(file, jastrow_een_nucleus)

def trexio_write_jastrow_een_nucleus_64(file: "trexio_s", jastrow_een_nucleus: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_een_nucleus_64(file, jastrow_een_nucleus)

def trexio_read_safe_jastrow_een_nucleus(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_een_nucleus(file, dset_out)

def trexio_write_safe_jastrow_een_nucleus(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_een_nucleus(file, dset_in)

def trexio_read_safe_jastrow_een_nucleus_32(file: "trexio_s", dset_out: "int32_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_een_nucleus_32(file, dset_out)

def trexio_write_safe_jastrow_een_nucleus_32(file: "trexio_s", dset_in: "int32_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_een_nucleus_32(file, dset_in)

def trexio_read_safe_jastrow_een_nucleus_64(file: "trexio_s", dset_out: "int64_t *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_een_nucleus_64(file, dset_out)

def trexio_write_safe_jastrow_een_nucleus_64(file: "trexio_s", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_een_nucleus_64(file, dset_in)

def trexio_has_jastrow_en_scaling(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow_en_scaling(file)

def trexio_read_jastrow_en_scaling(file: "trexio_s", jastrow_en_scaling: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_en_scaling(file, jastrow_en_scaling)

def trexio_write_jastrow_en_scaling(file: "trexio_s", jastrow_en_scaling: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en_scaling(file, jastrow_en_scaling)

def trexio_read_jastrow_en_scaling_32(file: "trexio_s", jastrow_en_scaling: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_en_scaling_32(file, jastrow_en_scaling)

def trexio_write_jastrow_en_scaling_32(file: "trexio_s", jastrow_en_scaling: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en_scaling_32(file, jastrow_en_scaling)

def trexio_read_jastrow_en_scaling_64(file: "trexio_s", jastrow_en_scaling: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_jastrow_en_scaling_64(file, jastrow_en_scaling)

def trexio_write_jastrow_en_scaling_64(file: "trexio_s", jastrow_en_scaling: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_jastrow_en_scaling_64(file, jastrow_en_scaling)

def trexio_read_safe_jastrow_en_scaling(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_en_scaling(file, dset_out)

def trexio_write_safe_jastrow_en_scaling(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_en_scaling(file, dset_in)

def trexio_read_safe_jastrow_en_scaling_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_en_scaling_32(file, dset_out)

def trexio_write_safe_jastrow_en_scaling_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_en_scaling_32(file, dset_in)

def trexio_read_safe_jastrow_en_scaling_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_jastrow_en_scaling_64(file, dset_out)

def trexio_write_safe_jastrow_en_scaling_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_jastrow_en_scaling_64(file, dset_in)

def trexio_has_qmc_point(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_qmc_point(file)

def trexio_read_qmc_point(file: "trexio_s", qmc_point: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_qmc_point(file, qmc_point)

def trexio_write_qmc_point(file: "trexio_s", qmc_point: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_point(file, qmc_point)

def trexio_read_qmc_point_32(file: "trexio_s", qmc_point: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_qmc_point_32(file, qmc_point)

def trexio_write_qmc_point_32(file: "trexio_s", qmc_point: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_point_32(file, qmc_point)

def trexio_read_qmc_point_64(file: "trexio_s", qmc_point: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_qmc_point_64(file, qmc_point)

def trexio_write_qmc_point_64(file: "trexio_s", qmc_point: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_point_64(file, qmc_point)

def trexio_read_safe_qmc_point(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_qmc_point(file, dset_out)

def trexio_write_safe_qmc_point(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_qmc_point(file, dset_in)

def trexio_read_safe_qmc_point_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_qmc_point_32(file, dset_out)

def trexio_write_safe_qmc_point_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_qmc_point_32(file, dset_in)

def trexio_read_safe_qmc_point_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_qmc_point_64(file, dset_out)

def trexio_write_safe_qmc_point_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_qmc_point_64(file, dset_in)

def trexio_has_qmc_psi(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_qmc_psi(file)

def trexio_read_qmc_psi(file: "trexio_s", qmc_psi: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_qmc_psi(file, qmc_psi)

def trexio_write_qmc_psi(file: "trexio_s", qmc_psi: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_psi(file, qmc_psi)

def trexio_read_qmc_psi_32(file: "trexio_s", qmc_psi: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_qmc_psi_32(file, qmc_psi)

def trexio_write_qmc_psi_32(file: "trexio_s", qmc_psi: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_psi_32(file, qmc_psi)

def trexio_read_qmc_psi_64(file: "trexio_s", qmc_psi: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_qmc_psi_64(file, qmc_psi)

def trexio_write_qmc_psi_64(file: "trexio_s", qmc_psi: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_psi_64(file, qmc_psi)

def trexio_read_safe_qmc_psi(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_qmc_psi(file, dset_out)

def trexio_write_safe_qmc_psi(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_qmc_psi(file, dset_in)

def trexio_read_safe_qmc_psi_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_qmc_psi_32(file, dset_out)

def trexio_write_safe_qmc_psi_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_qmc_psi_32(file, dset_in)

def trexio_read_safe_qmc_psi_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_qmc_psi_64(file, dset_out)

def trexio_write_safe_qmc_psi_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_qmc_psi_64(file, dset_in)

def trexio_has_qmc_e_loc(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_qmc_e_loc(file)

def trexio_read_qmc_e_loc(file: "trexio_s", qmc_e_loc: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_qmc_e_loc(file, qmc_e_loc)

def trexio_write_qmc_e_loc(file: "trexio_s", qmc_e_loc: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_e_loc(file, qmc_e_loc)

def trexio_read_qmc_e_loc_32(file: "trexio_s", qmc_e_loc: "float *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_qmc_e_loc_32(file, qmc_e_loc)

def trexio_write_qmc_e_loc_32(file: "trexio_s", qmc_e_loc: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_e_loc_32(file, qmc_e_loc)

def trexio_read_qmc_e_loc_64(file: "trexio_s", qmc_e_loc: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_qmc_e_loc_64(file, qmc_e_loc)

def trexio_write_qmc_e_loc_64(file: "trexio_s", qmc_e_loc: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_qmc_e_loc_64(file, qmc_e_loc)

def trexio_read_safe_qmc_e_loc(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_qmc_e_loc(file, dset_out)

def trexio_write_safe_qmc_e_loc(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_qmc_e_loc(file, dset_in)

def trexio_read_safe_qmc_e_loc_32(file: "trexio_s", dset_out: "float *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_qmc_e_loc_32(file, dset_out)

def trexio_write_safe_qmc_e_loc_32(file: "trexio_s", dset_in: "float const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_qmc_e_loc_32(file, dset_in)

def trexio_read_safe_qmc_e_loc_64(file: "trexio_s", dset_out: "double *const") -> "int64_t const":
    return _pytrexio.trexio_read_safe_qmc_e_loc_64(file, dset_out)

def trexio_write_safe_qmc_e_loc_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_qmc_e_loc_64(file, dset_in)

def trexio_has_ao_2e_int_eri(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_2e_int_eri(file)

def trexio_read_ao_2e_int_eri(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_2e_int_eri(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_ao_2e_int_eri_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_ao_2e_int_eri_size(file)

def trexio_write_ao_2e_int_eri(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_2e_int_eri(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_ao_2e_int_eri(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_ao_2e_int_eri(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_ao_2e_int_eri(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_2e_int_eri(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_ao_2e_int_eri_lr(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_2e_int_eri_lr(file)

def trexio_read_ao_2e_int_eri_lr(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_2e_int_eri_lr(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_ao_2e_int_eri_lr_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_ao_2e_int_eri_lr_size(file)

def trexio_write_ao_2e_int_eri_lr(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_2e_int_eri_lr(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_ao_2e_int_eri_lr(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_ao_2e_int_eri_lr(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_ao_2e_int_eri_lr(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_2e_int_eri_lr(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_ao_2e_int_eri_cholesky(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_2e_int_eri_cholesky(file)

def trexio_read_ao_2e_int_eri_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_2e_int_eri_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_ao_2e_int_eri_cholesky_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_ao_2e_int_eri_cholesky_size(file)

def trexio_write_ao_2e_int_eri_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_2e_int_eri_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_ao_2e_int_eri_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_ao_2e_int_eri_cholesky(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_ao_2e_int_eri_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_2e_int_eri_cholesky(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_ao_2e_int_eri_lr_cholesky(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_2e_int_eri_lr_cholesky(file)

def trexio_read_ao_2e_int_eri_lr_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_2e_int_eri_lr_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_ao_2e_int_eri_lr_cholesky_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_ao_2e_int_eri_lr_cholesky_size(file)

def trexio_write_ao_2e_int_eri_lr_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_ao_2e_int_eri_lr_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_ao_2e_int_eri_lr_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_ao_2e_int_eri_lr_cholesky(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_ao_2e_int_eri_lr_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_2e_int_eri_lr_cholesky(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_mo_2e_int_eri(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_2e_int_eri(file)

def trexio_read_mo_2e_int_eri(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_2e_int_eri(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_mo_2e_int_eri_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_mo_2e_int_eri_size(file)

def trexio_write_mo_2e_int_eri(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_2e_int_eri(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_mo_2e_int_eri(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_mo_2e_int_eri(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_mo_2e_int_eri(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_2e_int_eri(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_mo_2e_int_eri_lr(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_2e_int_eri_lr(file)

def trexio_read_mo_2e_int_eri_lr(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_2e_int_eri_lr(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_mo_2e_int_eri_lr_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_mo_2e_int_eri_lr_size(file)

def trexio_write_mo_2e_int_eri_lr(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_2e_int_eri_lr(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_mo_2e_int_eri_lr(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_mo_2e_int_eri_lr(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_mo_2e_int_eri_lr(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_2e_int_eri_lr(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_mo_2e_int_eri_cholesky(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_2e_int_eri_cholesky(file)

def trexio_read_mo_2e_int_eri_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_2e_int_eri_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_mo_2e_int_eri_cholesky_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_mo_2e_int_eri_cholesky_size(file)

def trexio_write_mo_2e_int_eri_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_2e_int_eri_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_mo_2e_int_eri_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_mo_2e_int_eri_cholesky(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_mo_2e_int_eri_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_2e_int_eri_cholesky(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_mo_2e_int_eri_lr_cholesky(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_2e_int_eri_lr_cholesky(file)

def trexio_read_mo_2e_int_eri_lr_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_2e_int_eri_lr_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_mo_2e_int_eri_lr_cholesky_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_mo_2e_int_eri_lr_cholesky_size(file)

def trexio_write_mo_2e_int_eri_lr_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_2e_int_eri_lr_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_mo_2e_int_eri_lr_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_mo_2e_int_eri_lr_cholesky(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_mo_2e_int_eri_lr_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_2e_int_eri_lr_cholesky(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_csf_det_coefficient(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_csf_det_coefficient(file)

def trexio_read_csf_det_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_csf_det_coefficient(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_csf_det_coefficient_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_csf_det_coefficient_size(file)

def trexio_write_csf_det_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_csf_det_coefficient(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_csf_det_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_csf_det_coefficient(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_csf_det_coefficient(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_csf_det_coefficient(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_amplitude_single(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_amplitude_single(file)

def trexio_read_amplitude_single(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_amplitude_single(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_amplitude_single_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_amplitude_single_size(file)

def trexio_write_amplitude_single(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_amplitude_single(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_amplitude_single(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_amplitude_single(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_amplitude_single(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_amplitude_single(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_amplitude_single_exp(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_amplitude_single_exp(file)

def trexio_read_amplitude_single_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_amplitude_single_exp(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_amplitude_single_exp_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_amplitude_single_exp_size(file)

def trexio_write_amplitude_single_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_amplitude_single_exp(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_amplitude_single_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_amplitude_single_exp(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_amplitude_single_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_amplitude_single_exp(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_amplitude_double(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_amplitude_double(file)

def trexio_read_amplitude_double(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_amplitude_double(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_amplitude_double_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_amplitude_double_size(file)

def trexio_write_amplitude_double(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_amplitude_double(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_amplitude_double(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_amplitude_double(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_amplitude_double(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_amplitude_double(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_amplitude_double_exp(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_amplitude_double_exp(file)

def trexio_read_amplitude_double_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_amplitude_double_exp(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_amplitude_double_exp_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_amplitude_double_exp_size(file)

def trexio_write_amplitude_double_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_amplitude_double_exp(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_amplitude_double_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_amplitude_double_exp(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_amplitude_double_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_amplitude_double_exp(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_amplitude_triple(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_amplitude_triple(file)

def trexio_read_amplitude_triple(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_amplitude_triple(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_amplitude_triple_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_amplitude_triple_size(file)

def trexio_write_amplitude_triple(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_amplitude_triple(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_amplitude_triple(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_amplitude_triple(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_amplitude_triple(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_amplitude_triple(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_amplitude_triple_exp(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_amplitude_triple_exp(file)

def trexio_read_amplitude_triple_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_amplitude_triple_exp(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_amplitude_triple_exp_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_amplitude_triple_exp_size(file)

def trexio_write_amplitude_triple_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_amplitude_triple_exp(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_amplitude_triple_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_amplitude_triple_exp(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_amplitude_triple_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_amplitude_triple_exp(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_amplitude_quadruple(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_amplitude_quadruple(file)

def trexio_read_amplitude_quadruple(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_amplitude_quadruple(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_amplitude_quadruple_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_amplitude_quadruple_size(file)

def trexio_write_amplitude_quadruple(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_amplitude_quadruple(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_amplitude_quadruple(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_amplitude_quadruple(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_amplitude_quadruple(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_amplitude_quadruple(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_amplitude_quadruple_exp(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_amplitude_quadruple_exp(file)

def trexio_read_amplitude_quadruple_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_amplitude_quadruple_exp(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_amplitude_quadruple_exp_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_amplitude_quadruple_exp_size(file)

def trexio_write_amplitude_quadruple_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_amplitude_quadruple_exp(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_amplitude_quadruple_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_amplitude_quadruple_exp(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_amplitude_quadruple_exp(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_amplitude_quadruple_exp(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_rdm_2e(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e(file)

def trexio_read_rdm_2e(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_2e(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_rdm_2e_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_size(file)

def trexio_write_rdm_2e(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_rdm_2e(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_rdm_2e(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_rdm_2e(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_2e(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_rdm_2e_upup(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e_upup(file)

def trexio_read_rdm_2e_upup(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_2e_upup(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_rdm_2e_upup_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_upup_size(file)

def trexio_write_rdm_2e_upup(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_upup(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_rdm_2e_upup(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_rdm_2e_upup(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_rdm_2e_upup(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_2e_upup(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_rdm_2e_dndn(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e_dndn(file)

def trexio_read_rdm_2e_dndn(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_2e_dndn(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_rdm_2e_dndn_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_dndn_size(file)

def trexio_write_rdm_2e_dndn(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_dndn(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_rdm_2e_dndn(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_rdm_2e_dndn(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_rdm_2e_dndn(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_2e_dndn(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_rdm_2e_updn(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e_updn(file)

def trexio_read_rdm_2e_updn(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_2e_updn(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_rdm_2e_updn_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_updn_size(file)

def trexio_write_rdm_2e_updn(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_updn(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_rdm_2e_updn(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_rdm_2e_updn(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_rdm_2e_updn(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_2e_updn(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_rdm_2e_cholesky(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e_cholesky(file)

def trexio_read_rdm_2e_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_2e_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_rdm_2e_cholesky_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_cholesky_size(file)

def trexio_write_rdm_2e_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_rdm_2e_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_rdm_2e_cholesky(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_rdm_2e_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_2e_cholesky(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_rdm_2e_upup_cholesky(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e_upup_cholesky(file)

def trexio_read_rdm_2e_upup_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_2e_upup_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_rdm_2e_upup_cholesky_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_upup_cholesky_size(file)

def trexio_write_rdm_2e_upup_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_upup_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_rdm_2e_upup_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_rdm_2e_upup_cholesky(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_rdm_2e_upup_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_2e_upup_cholesky(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_rdm_2e_dndn_cholesky(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e_dndn_cholesky(file)

def trexio_read_rdm_2e_dndn_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_2e_dndn_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_rdm_2e_dndn_cholesky_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_dndn_cholesky_size(file)

def trexio_write_rdm_2e_dndn_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_dndn_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_rdm_2e_dndn_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_rdm_2e_dndn_cholesky(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_rdm_2e_dndn_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_2e_dndn_cholesky(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_rdm_2e_updn_cholesky(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm_2e_updn_cholesky(file)

def trexio_read_rdm_2e_updn_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", index_sparse: "int32_t *const", value_sparse: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_rdm_2e_updn_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_rdm_2e_updn_cholesky_size(file: "trexio_s") -> "int64_t *const":
    return _pytrexio.trexio_read_rdm_2e_updn_cholesky_size(file)

def trexio_write_rdm_2e_updn_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse: "int32_t const *", value_sparse: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_rdm_2e_updn_cholesky(file, offset_file, buffer_size, index_sparse, value_sparse)

def trexio_read_safe_rdm_2e_updn_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", index_sparse_read: "int32_t *const", value_sparse_read: "double *const") -> "int64_t *const, int64_t const, int64_t const":
    return _pytrexio.trexio_read_safe_rdm_2e_updn_cholesky(file, offset_file, buffer_size_read, index_sparse_read, value_sparse_read)

def trexio_write_safe_rdm_2e_updn_cholesky(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", index_sparse_write: "int32_t const *", value_sparse_write: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_rdm_2e_updn_cholesky(file, offset_file, buffer_size, index_sparse_write, value_sparse_write)

def trexio_has_metadata_code(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_metadata_code(file)

def trexio_read_metadata_code_low(file: "trexio_s", max_str_len: "int32_t const") -> "char *":
    return _pytrexio.trexio_read_metadata_code_low(file, max_str_len)

def trexio_write_metadata_code_low(file: "trexio_s", dset_in: "char *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_code_low(file, dset_in, max_str_len)

def trexio_read_metadata_code(file: "trexio_s", dset_out: "char **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_metadata_code(file, dset_out, max_str_len)

def trexio_write_metadata_code(file: "trexio_s", dset_in: "char const **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_code(file, dset_in, max_str_len)

def trexio_has_metadata_author(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_metadata_author(file)

def trexio_read_metadata_author_low(file: "trexio_s", max_str_len: "int32_t const") -> "char *":
    return _pytrexio.trexio_read_metadata_author_low(file, max_str_len)

def trexio_write_metadata_author_low(file: "trexio_s", dset_in: "char *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_author_low(file, dset_in, max_str_len)

def trexio_read_metadata_author(file: "trexio_s", dset_out: "char **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_metadata_author(file, dset_out, max_str_len)

def trexio_write_metadata_author(file: "trexio_s", dset_in: "char const **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_metadata_author(file, dset_in, max_str_len)

def trexio_has_nucleus_label(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_nucleus_label(file)

def trexio_read_nucleus_label_low(file: "trexio_s", max_str_len: "int32_t const") -> "char *":
    return _pytrexio.trexio_read_nucleus_label_low(file, max_str_len)

def trexio_write_nucleus_label_low(file: "trexio_s", dset_in: "char *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_label_low(file, dset_in, max_str_len)

def trexio_read_nucleus_label(file: "trexio_s", dset_out: "char **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_nucleus_label(file, dset_out, max_str_len)

def trexio_write_nucleus_label(file: "trexio_s", dset_in: "char const **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_nucleus_label(file, dset_in, max_str_len)

def trexio_has_state_label(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_state_label(file)

def trexio_read_state_label_low(file: "trexio_s", max_str_len: "int32_t const") -> "char *":
    return _pytrexio.trexio_read_state_label_low(file, max_str_len)

def trexio_write_state_label_low(file: "trexio_s", dset_in: "char *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_state_label_low(file, dset_in, max_str_len)

def trexio_read_state_label(file: "trexio_s", dset_out: "char **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_state_label(file, dset_out, max_str_len)

def trexio_write_state_label(file: "trexio_s", dset_in: "char const **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_state_label(file, dset_in, max_str_len)

def trexio_has_state_file_name(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_state_file_name(file)

def trexio_read_state_file_name_low(file: "trexio_s", max_str_len: "int32_t const") -> "char *":
    return _pytrexio.trexio_read_state_file_name_low(file, max_str_len)

def trexio_write_state_file_name_low(file: "trexio_s", dset_in: "char *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_state_file_name_low(file, dset_in, max_str_len)

def trexio_read_state_file_name(file: "trexio_s", dset_out: "char **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_state_file_name(file, dset_out, max_str_len)

def trexio_write_state_file_name(file: "trexio_s", dset_in: "char const **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_state_file_name(file, dset_in, max_str_len)

def trexio_has_mo_class(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_class(file)

def trexio_read_mo_class_low(file: "trexio_s", max_str_len: "int32_t const") -> "char *":
    return _pytrexio.trexio_read_mo_class_low(file, max_str_len)

def trexio_write_mo_class_low(file: "trexio_s", dset_in: "char *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_class_low(file, dset_in, max_str_len)

def trexio_read_mo_class(file: "trexio_s", dset_out: "char **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_class(file, dset_out, max_str_len)

def trexio_write_mo_class(file: "trexio_s", dset_in: "char const **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_class(file, dset_in, max_str_len)

def trexio_has_mo_symmetry(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_symmetry(file)

def trexio_read_mo_symmetry_low(file: "trexio_s", max_str_len: "int32_t const") -> "char *":
    return _pytrexio.trexio_read_mo_symmetry_low(file, max_str_len)

def trexio_write_mo_symmetry_low(file: "trexio_s", dset_in: "char *", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_symmetry_low(file, dset_in, max_str_len)

def trexio_read_mo_symmetry(file: "trexio_s", dset_out: "char **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_symmetry(file, dset_out, max_str_len)

def trexio_write_mo_symmetry(file: "trexio_s", dset_in: "char const **", max_str_len: "int32_t const") -> "trexio_exit_code":
    return _pytrexio.trexio_write_mo_symmetry(file, dset_in, max_str_len)

def trexio_has_metadata(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_metadata(file)

def trexio_has_nucleus(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_nucleus(file)

def trexio_has_cell(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_cell(file)

def trexio_has_pbc(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_pbc(file)

def trexio_has_electron(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_electron(file)

def trexio_has_state(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_state(file)

def trexio_has_basis(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_basis(file)

def trexio_has_ecp(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ecp(file)

def trexio_has_grid(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_grid(file)

def trexio_has_ao(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao(file)

def trexio_has_ao_1e_int(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int(file)

def trexio_has_ao_2e_int(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_2e_int(file)

def trexio_has_mo(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo(file)

def trexio_has_mo_1e_int(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int(file)

def trexio_has_mo_2e_int(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_2e_int(file)

def trexio_has_determinant(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_determinant(file)

def trexio_has_csf(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_csf(file)

def trexio_has_amplitude(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_amplitude(file)

def trexio_has_rdm(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_rdm(file)

def trexio_has_jastrow(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_jastrow(file)

def trexio_has_qmc(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_qmc(file)

def trexio_has_determinant_list(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_determinant_list(file)

def trexio_read_determinant_list(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t *const", dset: "int64_t *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_determinant_list(file, offset_file, buffer_size, dset)

def trexio_read_safe_determinant_list(file: "trexio_s", offset_file: "int64_t const", buffer_size_read: "int64_t *const", dset_out: "int64_t *const") -> "int64_t *const, int64_t const":
    return _pytrexio.trexio_read_safe_determinant_list(file, offset_file, buffer_size_read, dset_out)

def trexio_write_determinant_list(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", dset: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_determinant_list(file, offset_file, buffer_size, dset)

def trexio_write_safe_determinant_list(file: "trexio_s", offset_file: "int64_t const", buffer_size: "int64_t const", dset_in: "int64_t const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_determinant_list(file, offset_file, buffer_size, dset_in)

def trexio_get_int64_num(file: "trexio_s") -> "int32_t *const":
    return _pytrexio.trexio_get_int64_num(file)


