# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# 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)
    version = property(_pytrexio.trexio_s_version_get, _pytrexio.trexio_s_version_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)
    padding = property(_pytrexio.trexio_s_padding_get, _pytrexio.trexio_s_padding_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_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)
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

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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_local(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_ao_1e_int_ecp_local(file)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def trexio_write_safe_ao_1e_int_ecp_non_local_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_1e_int_ecp_non_local_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_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", ao_2e_int_eri: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_2e_int_eri(file, ao_2e_int_eri)

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

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

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

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

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

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

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

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

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

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

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

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", ao_2e_int_eri_lr: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_ao_2e_int_eri_lr(file, ao_2e_int_eri_lr)

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

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

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

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

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

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

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

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

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

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

def trexio_write_safe_ao_2e_int_eri_lr_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_ao_2e_int_eri_lr_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_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_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_local(file: "trexio_s") -> "trexio_exit_code":
    return _pytrexio.trexio_has_mo_1e_int_ecp_local(file)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def trexio_write_safe_mo_1e_int_ecp_non_local_64(file: "trexio_s", dset_in: "double const *") -> "trexio_exit_code":
    return _pytrexio.trexio_write_safe_mo_1e_int_ecp_non_local_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_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", mo_2e_int_eri: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_2e_int_eri(file, mo_2e_int_eri)

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

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

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

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

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

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

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

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

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

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

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

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", mo_2e_int_eri_lr: "double *const") -> "trexio_exit_code":
    return _pytrexio.trexio_read_mo_2e_int_eri_lr(file, mo_2e_int_eri_lr)

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

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

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

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

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

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

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

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

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

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

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

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 const *", 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 const *", 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 const *", 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_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 const *", 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 const *", 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)


