cassandra-cpp-sys 0.10.0

/* automatically generated by rust-bindgen */

#![allow(dead_code,
         non_camel_case_types,
         non_upper_case_globals,
         non_snake_case)]
pub type ptrdiff_t = isize;
pub type size_t = usize;
pub type wchar_t = ::std::os::raw::c_int;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum cass_bool_t { cass_false = 0, cass_true = 1, }
pub type cass_float_t = f32;
pub type cass_double_t = f64;
pub type cass_int8_t = ::std::os::raw::c_char;
pub type cass_uint8_t = ::std::os::raw::c_uchar;
pub type cass_int16_t = ::std::os::raw::c_short;
pub type cass_uint16_t = ::std::os::raw::c_ushort;
pub type cass_int32_t = ::std::os::raw::c_int;
pub type cass_uint32_t = ::std::os::raw::c_uint;
pub type cass_int64_t = ::std::os::raw::c_long;
pub type cass_uint64_t = ::std::os::raw::c_ulong;
pub type cass_byte_t = cass_uint8_t;
pub type cass_duration_t = cass_uint64_t;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CassInet_ {
    pub address: [cass_uint8_t; 16usize],
    pub address_length: cass_uint8_t,
}
impl ::std::default::Default for CassInet_ {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type CassInet = CassInet_;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CassUuid_ {
    pub time_and_version: cass_uint64_t,
    pub clock_seq_and_node: cass_uint64_t,
}
impl ::std::default::Default for CassUuid_ {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type CassUuid = CassUuid_;
pub enum CassCluster_ { }
pub type CassCluster = CassCluster_;
pub enum CassSession_ { }
pub type CassSession = CassSession_;
pub enum CassStatement_ { }
pub type CassStatement = CassStatement_;
pub enum CassBatch_ { }
pub type CassBatch = CassBatch_;
pub enum CassFuture_ { }
pub type CassFuture = CassFuture_;
pub enum CassPrepared_ { }
pub type CassPrepared = CassPrepared_;
pub enum CassResult_ { }
pub type CassResult = CassResult_;
pub enum CassErrorResult_ { }
pub type CassErrorResult = CassErrorResult_;
pub enum CassIterator_ { }
pub type CassIterator = CassIterator_;
pub enum CassRow_ { }
pub type CassRow = CassRow_;
pub enum CassValue_ { }
pub type CassValue = CassValue_;
pub enum CassDataType_ { }
pub type CassDataType = CassDataType_;
pub enum CassFunctionMeta_ { }
pub type CassFunctionMeta = CassFunctionMeta_;
pub enum CassAggregateMeta_ { }
pub type CassAggregateMeta = CassAggregateMeta_;
pub enum CassCollection_ { }
pub type CassCollection = CassCollection_;
pub enum CassTuple_ { }
pub type CassTuple = CassTuple_;
pub enum CassUserType_ { }
pub type CassUserType = CassUserType_;
pub enum CassSsl_ { }
pub type CassSsl = CassSsl_;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CassVersion_ {
    pub major_version: ::std::os::raw::c_int,
    pub minor_version: ::std::os::raw::c_int,
    pub patch_version: ::std::os::raw::c_int,
}
impl ::std::default::Default for CassVersion_ {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type CassVersion = CassVersion_;
pub enum CassSchemaMeta_ { }
pub type CassSchemaMeta = CassSchemaMeta_;
pub enum CassKeyspaceMeta_ { }
pub type CassKeyspaceMeta = CassKeyspaceMeta_;
pub enum CassTableMeta_ { }
pub type CassTableMeta = CassTableMeta_;
pub enum CassMaterializedViewMeta_ { }
pub type CassMaterializedViewMeta = CassMaterializedViewMeta_;
pub enum CassColumnMeta_ { }
pub type CassColumnMeta = CassColumnMeta_;
pub enum CassIndexMeta_ { }
pub type CassIndexMeta = CassIndexMeta_;
pub enum CassUuidGen_ { }
pub type CassUuidGen = CassUuidGen_;
pub enum CassTimestampGen_ { }
pub type CassTimestampGen = CassTimestampGen_;
pub enum CassRetryPolicy_ { }
pub type CassRetryPolicy = CassRetryPolicy_;
pub enum CassCustomPayload_ { }
pub type CassCustomPayload = CassCustomPayload_;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CassMetrics_ {
    pub requests: Struct_Unnamed1,
    pub stats: Struct_Unnamed2,
    pub errors: Struct_Unnamed3,
}
impl ::std::default::Default for CassMetrics_ {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Struct_Unnamed1 {
    pub min: cass_uint64_t,
    pub max: cass_uint64_t,
    pub mean: cass_uint64_t,
    pub stddev: cass_uint64_t,
    pub median: cass_uint64_t,
    pub percentile_75th: cass_uint64_t,
    pub percentile_95th: cass_uint64_t,
    pub percentile_98th: cass_uint64_t,
    pub percentile_99th: cass_uint64_t,
    pub percentile_999th: cass_uint64_t,
    pub mean_rate: cass_double_t,
    pub one_minute_rate: cass_double_t,
    pub five_minute_rate: cass_double_t,
    pub fifteen_minute_rate: cass_double_t,
}
impl ::std::default::Default for Struct_Unnamed1 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Struct_Unnamed2 {
    pub total_connections: cass_uint64_t,
    pub available_connections: cass_uint64_t,
    pub exceeded_pending_requests_water_mark: cass_uint64_t,
    pub exceeded_write_bytes_water_mark: cass_uint64_t,
}
impl ::std::default::Default for Struct_Unnamed2 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct Struct_Unnamed3 {
    pub connection_timeouts: cass_uint64_t,
    pub pending_request_timeouts: cass_uint64_t,
    pub request_timeouts: cass_uint64_t,
}
impl ::std::default::Default for Struct_Unnamed3 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type CassMetrics = CassMetrics_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassConsistency_ {
    CASS_CONSISTENCY_UNKNOWN = 65535,
    CASS_CONSISTENCY_ANY = 0,
    CASS_CONSISTENCY_ONE = 1,
    CASS_CONSISTENCY_TWO = 2,
    CASS_CONSISTENCY_THREE = 3,
    CASS_CONSISTENCY_QUORUM = 4,
    CASS_CONSISTENCY_ALL = 5,
    CASS_CONSISTENCY_LOCAL_QUORUM = 6,
    CASS_CONSISTENCY_EACH_QUORUM = 7,
    CASS_CONSISTENCY_SERIAL = 8,
    CASS_CONSISTENCY_LOCAL_SERIAL = 9,
    CASS_CONSISTENCY_LOCAL_ONE = 10,
}
pub type CassConsistency = CassConsistency_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassWriteType_ {
    CASS_WRITE_TYPE_UKNOWN = 0,
    CASS_WRITE_TYPE_SIMPLE = 1,
    CASS_WRITE_TYPE_BATCH = 2,
    CASS_WRITE_TYPE_UNLOGGED_BATCH = 3,
    CASS_WRITE_TYPE_COUNTER = 4,
    CASS_WRITE_TYPE_BATCH_LOG = 5,
    CASS_WRITE_TYPE_CAS = 6,
}
pub type CassWriteType = CassWriteType_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassColumnType_ {
    CASS_COLUMN_TYPE_REGULAR = 0,
    CASS_COLUMN_TYPE_PARTITION_KEY = 1,
    CASS_COLUMN_TYPE_CLUSTERING_KEY = 2,
    CASS_COLUMN_TYPE_STATIC = 3,
    CASS_COLUMN_TYPE_COMPACT_VALUE = 4,
}
pub type CassColumnType = CassColumnType_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassIndexType_ {
    CASS_INDEX_TYPE_UNKNOWN = 0,
    CASS_INDEX_TYPE_KEYS = 1,
    CASS_INDEX_TYPE_CUSTOM = 2,
    CASS_INDEX_TYPE_COMPOSITES = 3,
}
pub type CassIndexType = CassIndexType_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassValueType_ {
    CASS_VALUE_TYPE_UNKNOWN = 65535,
    CASS_VALUE_TYPE_CUSTOM = 0,
    CASS_VALUE_TYPE_ASCII = 1,
    CASS_VALUE_TYPE_BIGINT = 2,
    CASS_VALUE_TYPE_BLOB = 3,
    CASS_VALUE_TYPE_BOOLEAN = 4,
    CASS_VALUE_TYPE_COUNTER = 5,
    CASS_VALUE_TYPE_DECIMAL = 6,
    CASS_VALUE_TYPE_DOUBLE = 7,
    CASS_VALUE_TYPE_FLOAT = 8,
    CASS_VALUE_TYPE_INT = 9,
    CASS_VALUE_TYPE_TEXT = 10,
    CASS_VALUE_TYPE_TIMESTAMP = 11,
    CASS_VALUE_TYPE_UUID = 12,
    CASS_VALUE_TYPE_VARCHAR = 13,
    CASS_VALUE_TYPE_VARINT = 14,
    CASS_VALUE_TYPE_TIMEUUID = 15,
    CASS_VALUE_TYPE_INET = 16,
    CASS_VALUE_TYPE_DATE = 17,
    CASS_VALUE_TYPE_TIME = 18,
    CASS_VALUE_TYPE_SMALL_INT = 19,
    CASS_VALUE_TYPE_TINY_INT = 20,
    CASS_VALUE_TYPE_LIST = 32,
    CASS_VALUE_TYPE_MAP = 33,
    CASS_VALUE_TYPE_SET = 34,
    CASS_VALUE_TYPE_UDT = 48,
    CASS_VALUE_TYPE_TUPLE = 49,
    CASS_VALUE_TYPE_LAST_ENTRY = 50,
}
pub type CassValueType = CassValueType_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassClusteringOrder_ {
    CASS_CLUSTERING_ORDER_NONE = 0,
    CASS_CLUSTERING_ORDER_ASC = 1,
    CASS_CLUSTERING_ORDER_DESC = 2,
}
pub type CassClusteringOrder = CassClusteringOrder_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassCollectionType_ {
    CASS_COLLECTION_TYPE_LIST = 32,
    CASS_COLLECTION_TYPE_MAP = 33,
    CASS_COLLECTION_TYPE_SET = 34,
}
pub type CassCollectionType = CassCollectionType_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassBatchType_ {
    CASS_BATCH_TYPE_LOGGED = 0,
    CASS_BATCH_TYPE_UNLOGGED = 1,
    CASS_BATCH_TYPE_COUNTER = 2,
}
pub type CassBatchType = CassBatchType_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassIteratorType_ {
    CASS_ITERATOR_TYPE_RESULT = 0,
    CASS_ITERATOR_TYPE_ROW = 1,
    CASS_ITERATOR_TYPE_COLLECTION = 2,
    CASS_ITERATOR_TYPE_MAP = 3,
    CASS_ITERATOR_TYPE_TUPLE = 4,
    CASS_ITERATOR_TYPE_USER_TYPE_FIELD = 5,
    CASS_ITERATOR_TYPE_META_FIELD = 6,
    CASS_ITERATOR_TYPE_KEYSPACE_META = 7,
    CASS_ITERATOR_TYPE_TABLE_META = 8,
    CASS_ITERATOR_TYPE_TYPE_META = 9,
    CASS_ITERATOR_TYPE_FUNCTION_META = 10,
    CASS_ITERATOR_TYPE_AGGREGATE_META = 11,
    CASS_ITERATOR_TYPE_COLUMN_META = 12,
    CASS_ITERATOR_TYPE_INDEX_META = 13,
    CASS_ITERATOR_TYPE_MATERIALIZED_VIEW_META = 14,
}
pub type CassIteratorType = CassIteratorType_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassLogLevel_ {
    CASS_LOG_DISABLED = 0,
    CASS_LOG_CRITICAL = 1,
    CASS_LOG_ERROR = 2,
    CASS_LOG_WARN = 3,
    CASS_LOG_INFO = 4,
    CASS_LOG_DEBUG = 5,
    CASS_LOG_TRACE = 6,
    CASS_LOG_LAST_ENTRY = 7,
}
pub type CassLogLevel = CassLogLevel_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassSslVerifyFlags {
    CASS_SSL_VERIFY_NONE = 0,
    CASS_SSL_VERIFY_PEER_CERT = 1,
    CASS_SSL_VERIFY_PEER_IDENTITY = 2,
    CASS_SSL_VERIFY_PEER_IDENTITY_DNS = 4,
}
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassErrorSource_ {
    CASS_ERROR_SOURCE_NONE = 0,
    CASS_ERROR_SOURCE_LIB = 1,
    CASS_ERROR_SOURCE_SERVER = 2,
    CASS_ERROR_SOURCE_SSL = 3,
    CASS_ERROR_SOURCE_COMPRESSION = 4,
}
pub type CassErrorSource = CassErrorSource_;
#[derive(Copy, Clone)]
#[repr(u32)]
#[derive(Debug)]
pub enum CassError_ {
    CASS_OK = 0,
    CASS_ERROR_LIB_BAD_PARAMS = 16777217,
    CASS_ERROR_LIB_NO_STREAMS = 16777218,
    CASS_ERROR_LIB_UNABLE_TO_INIT = 16777219,
    CASS_ERROR_LIB_MESSAGE_ENCODE = 16777220,
    CASS_ERROR_LIB_HOST_RESOLUTION = 16777221,
    CASS_ERROR_LIB_UNEXPECTED_RESPONSE = 16777222,
    CASS_ERROR_LIB_REQUEST_QUEUE_FULL = 16777223,
    CASS_ERROR_LIB_NO_AVAILABLE_IO_THREAD = 16777224,
    CASS_ERROR_LIB_WRITE_ERROR = 16777225,
    CASS_ERROR_LIB_NO_HOSTS_AVAILABLE = 16777226,
    CASS_ERROR_LIB_INDEX_OUT_OF_BOUNDS = 16777227,
    CASS_ERROR_LIB_INVALID_ITEM_COUNT = 16777228,
    CASS_ERROR_LIB_INVALID_VALUE_TYPE = 16777229,
    CASS_ERROR_LIB_REQUEST_TIMED_OUT = 16777230,
    CASS_ERROR_LIB_UNABLE_TO_SET_KEYSPACE = 16777231,
    CASS_ERROR_LIB_CALLBACK_ALREADY_SET = 16777232,
    CASS_ERROR_LIB_INVALID_STATEMENT_TYPE = 16777233,
    CASS_ERROR_LIB_NAME_DOES_NOT_EXIST = 16777234,
    CASS_ERROR_LIB_UNABLE_TO_DETERMINE_PROTOCOL = 16777235,
    CASS_ERROR_LIB_NULL_VALUE = 16777236,
    CASS_ERROR_LIB_NOT_IMPLEMENTED = 16777237,
    CASS_ERROR_LIB_UNABLE_TO_CONNECT = 16777238,
    CASS_ERROR_LIB_UNABLE_TO_CLOSE = 16777239,
    CASS_ERROR_LIB_NO_PAGING_STATE = 16777240,
    CASS_ERROR_LIB_PARAMETER_UNSET = 16777241,
    CASS_ERROR_LIB_INVALID_ERROR_RESULT_TYPE = 16777242,
    CASS_ERROR_LIB_INVALID_FUTURE_TYPE = 16777243,
    CASS_ERROR_LIB_INTERNAL_ERROR = 16777244,
    CASS_ERROR_LIB_INVALID_CUSTOM_TYPE = 16777245,
    CASS_ERROR_LIB_INVALID_DATA = 16777246,
    CASS_ERROR_LIB_NOT_ENOUGH_DATA = 16777247,
    CASS_ERROR_LIB_INVALID_STATE = 16777248,
    CASS_ERROR_LIB_NO_CUSTOM_PAYLOAD = 16777249,
    CASS_ERROR_SERVER_SERVER_ERROR = 33554432,
    CASS_ERROR_SERVER_PROTOCOL_ERROR = 33554442,
    CASS_ERROR_SERVER_BAD_CREDENTIALS = 33554688,
    CASS_ERROR_SERVER_UNAVAILABLE = 33558528,
    CASS_ERROR_SERVER_OVERLOADED = 33558529,
    CASS_ERROR_SERVER_IS_BOOTSTRAPPING = 33558530,
    CASS_ERROR_SERVER_TRUNCATE_ERROR = 33558531,
    CASS_ERROR_SERVER_WRITE_TIMEOUT = 33558784,
    CASS_ERROR_SERVER_READ_TIMEOUT = 33559040,
    CASS_ERROR_SERVER_READ_FAILURE = 33559296,
    CASS_ERROR_SERVER_FUNCTION_FAILURE = 33559552,
    CASS_ERROR_SERVER_WRITE_FAILURE = 33559808,
    CASS_ERROR_SERVER_SYNTAX_ERROR = 33562624,
    CASS_ERROR_SERVER_UNAUTHORIZED = 33562880,
    CASS_ERROR_SERVER_INVALID_QUERY = 33563136,
    CASS_ERROR_SERVER_CONFIG_ERROR = 33563392,
    CASS_ERROR_SERVER_ALREADY_EXISTS = 33563648,
    CASS_ERROR_SERVER_UNPREPARED = 33563904,
    CASS_ERROR_SSL_INVALID_CERT = 50331649,
    CASS_ERROR_SSL_INVALID_PRIVATE_KEY = 50331650,
    CASS_ERROR_SSL_NO_PEER_CERT = 50331651,
    CASS_ERROR_SSL_INVALID_PEER_CERT = 50331652,
    CASS_ERROR_SSL_IDENTITY_MISMATCH = 50331653,
    CASS_ERROR_SSL_PROTOCOL_ERROR = 50331654,
    CASS_ERROR_LAST_ENTRY = 50331655,
}
pub type CassError = CassError_;
pub type CassFutureCallback =
    ::std::option::Option<unsafe extern "C" fn(future: *mut CassFuture,
                                               data:
                                                   *mut ::std::os::raw::c_void)>;
#[repr(C)]
#[derive(Copy)]
pub struct CassLogMessage_ {
    pub time_ms: cass_uint64_t,
    pub severity: CassLogLevel,
    pub file: *const ::std::os::raw::c_char,
    pub line: ::std::os::raw::c_int,
    pub function: *const ::std::os::raw::c_char,
    pub message: [::std::os::raw::c_char; 1024usize],
}
impl ::std::clone::Clone for CassLogMessage_ {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for CassLogMessage_ {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type CassLogMessage = CassLogMessage_;
pub type CassLogCallback =
    ::std::option::Option<unsafe extern "C" fn(message: *const CassLogMessage,
                                               data:
                                                   *mut ::std::os::raw::c_void)>;
pub enum CassAuthenticator_ { }
pub type CassAuthenticator = CassAuthenticator_;
pub type CassAuthenticatorInitialCallback =
    ::std::option::Option<unsafe extern "C" fn(auth: *mut CassAuthenticator,
                                               data:
                                                   *mut ::std::os::raw::c_void)>;
pub type CassAuthenticatorChallengeCallback =
    ::std::option::Option<unsafe extern "C" fn(auth: *mut CassAuthenticator,
                                               data:
                                                   *mut ::std::os::raw::c_void,
                                               token:
                                                   *const ::std::os::raw::c_char,
                                               token_size: size_t)>;
pub type CassAuthenticatorSuccessCallback =
    ::std::option::Option<unsafe extern "C" fn(auth: *mut CassAuthenticator,
                                               data:
                                                   *mut ::std::os::raw::c_void,
                                               token:
                                                   *const ::std::os::raw::c_char,
                                               token_size: size_t)>;
pub type CassAuthenticatorCleanupCallback =
    ::std::option::Option<unsafe extern "C" fn(auth: *mut CassAuthenticator,
                                               data:
                                                   *mut ::std::os::raw::c_void)>;
pub type CassAuthenticatorDataCleanupCallback =
    ::std::option::Option<unsafe extern "C" fn(data:
                                                   *mut ::std::os::raw::c_void)>;
#[repr(C)]
#[derive(Copy, Clone)]
#[derive(Debug)]
pub struct CassAuthenticatorCallbacks_ {
    pub initial_callback: CassAuthenticatorInitialCallback,
    pub challenge_callback: CassAuthenticatorChallengeCallback,
    pub success_callback: CassAuthenticatorSuccessCallback,
    pub cleanup_callback: CassAuthenticatorCleanupCallback,
}
impl ::std::default::Default for CassAuthenticatorCallbacks_ {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type CassAuthenticatorCallbacks = CassAuthenticatorCallbacks_;

/// Per DataStax issue CPP-473, this symbol does not exist in the driver; expose it for
/// back-compatibility only.
pub fn cass_cluster_set_queue_size_log(_cluster: *mut CassCluster,
                                       _queue_size: ::std::os::raw::c_uint)
 -> CassError {
    CassError_::CASS_OK
}

#[link(name = "cassandra", kind = "dylib")]
extern "C" {
    pub fn cass_cluster_new() -> *mut CassCluster;
    pub fn cass_cluster_free(cluster: *mut CassCluster);
    pub fn cass_cluster_set_contact_points(cluster: *mut CassCluster,
                                           contact_points:
                                               *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_cluster_set_contact_points_n(cluster: *mut CassCluster,
                                             contact_points:
                                                 *const ::std::os::raw::c_char,
                                             contact_points_length: size_t)
     -> CassError;
    pub fn cass_cluster_set_port(cluster: *mut CassCluster,
                                 port: ::std::os::raw::c_int) -> CassError;
    pub fn cass_cluster_set_ssl(cluster: *mut CassCluster, ssl: *mut CassSsl);
    pub fn cass_cluster_set_authenticator_callbacks(cluster: *mut CassCluster,
                                                    exchange_callbacks:
                                                        *const CassAuthenticatorCallbacks,
                                                    cleanup_callback:
                                                        CassAuthenticatorDataCleanupCallback,
                                                    data:
                                                        *mut ::std::os::raw::c_void)
     -> CassError;
    pub fn cass_cluster_set_protocol_version(cluster: *mut CassCluster,
                                             protocol_version:
                                                 ::std::os::raw::c_int)
     -> CassError;
    pub fn cass_cluster_set_num_threads_io(cluster: *mut CassCluster,
                                           num_threads:
                                               ::std::os::raw::c_uint)
     -> CassError;
    pub fn cass_cluster_set_queue_size_io(cluster: *mut CassCluster,
                                          queue_size: ::std::os::raw::c_uint)
     -> CassError;
    pub fn cass_cluster_set_queue_size_event(cluster: *mut CassCluster,
                                             queue_size:
                                                 ::std::os::raw::c_uint)
     -> CassError;
// CPP-473 this symbol does not exist - exposed above.
//    pub fn cass_cluster_set_queue_size_log(cluster: *mut CassCluster,
//                                           queue_size: ::std::os::raw::c_uint)
//     -> CassError;
    pub fn cass_cluster_set_core_connections_per_host(cluster:
                                                          *mut CassCluster,
                                                      num_connections:
                                                          ::std::os::raw::c_uint)
     -> CassError;
    pub fn cass_cluster_set_max_connections_per_host(cluster:
                                                         *mut CassCluster,
                                                     num_connections:
                                                         ::std::os::raw::c_uint)
     -> CassError;
    pub fn cass_cluster_set_reconnect_wait_time(cluster: *mut CassCluster,
                                                wait_time:
                                                    ::std::os::raw::c_uint);
    pub fn cass_cluster_set_max_concurrent_creation(cluster: *mut CassCluster,
                                                    num_connections:
                                                        ::std::os::raw::c_uint)
     -> CassError;
    pub fn cass_cluster_set_max_concurrent_requests_threshold(cluster:
                                                                  *mut CassCluster,
                                                              num_requests:
                                                                  ::std::os::raw::c_uint)
     -> CassError;
    pub fn cass_cluster_set_max_requests_per_flush(cluster: *mut CassCluster,
                                                   num_requests:
                                                       ::std::os::raw::c_uint)
     -> CassError;
    pub fn cass_cluster_set_write_bytes_high_water_mark(cluster:
                                                            *mut CassCluster,
                                                        num_bytes:
                                                            ::std::os::raw::c_uint)
     -> CassError;
    pub fn cass_cluster_set_write_bytes_low_water_mark(cluster:
                                                           *mut CassCluster,
                                                       num_bytes:
                                                           ::std::os::raw::c_uint)
     -> CassError;
    pub fn cass_cluster_set_pending_requests_high_water_mark(cluster:
                                                                 *mut CassCluster,
                                                             num_requests:
                                                                 ::std::os::raw::c_uint)
     -> CassError;
    pub fn cass_cluster_set_pending_requests_low_water_mark(cluster:
                                                                *mut CassCluster,
                                                            num_requests:
                                                                ::std::os::raw::c_uint)
     -> CassError;
    pub fn cass_cluster_set_connect_timeout(cluster: *mut CassCluster,
                                            timeout_ms:
                                                ::std::os::raw::c_uint);
    pub fn cass_cluster_set_request_timeout(cluster: *mut CassCluster,
                                            timeout_ms:
                                                ::std::os::raw::c_uint);
    pub fn cass_cluster_set_resolve_timeout(cluster: *mut CassCluster,
                                            timeout_ms:
                                                ::std::os::raw::c_uint);
    pub fn cass_cluster_set_credentials(cluster: *mut CassCluster,
                                        username:
                                            *const ::std::os::raw::c_char,
                                        password:
                                            *const ::std::os::raw::c_char);
    pub fn cass_cluster_set_credentials_n(cluster: *mut CassCluster,
                                          username:
                                              *const ::std::os::raw::c_char,
                                          username_length: size_t,
                                          password:
                                              *const ::std::os::raw::c_char,
                                          password_length: size_t);
    pub fn cass_cluster_set_load_balance_round_robin(cluster:
                                                         *mut CassCluster);
    pub fn cass_cluster_set_load_balance_dc_aware(cluster: *mut CassCluster,
                                                  local_dc:
                                                      *const ::std::os::raw::c_char,
                                                  used_hosts_per_remote_dc:
                                                      ::std::os::raw::c_uint,
                                                  allow_remote_dcs_for_local_cl:
                                                      cass_bool_t)
     -> CassError;
    pub fn cass_cluster_set_load_balance_dc_aware_n(cluster: *mut CassCluster,
                                                    local_dc:
                                                        *const ::std::os::raw::c_char,
                                                    local_dc_length: size_t,
                                                    used_hosts_per_remote_dc:
                                                        ::std::os::raw::c_uint,
                                                    allow_remote_dcs_for_local_cl:
                                                        cass_bool_t)
     -> CassError;
    pub fn cass_cluster_set_token_aware_routing(cluster: *mut CassCluster,
                                                enabled: cass_bool_t);
    pub fn cass_cluster_set_latency_aware_routing(cluster: *mut CassCluster,
                                                  enabled: cass_bool_t);
    pub fn cass_cluster_set_latency_aware_routing_settings(cluster:
                                                               *mut CassCluster,
                                                           exclusion_threshold:
                                                               cass_double_t,
                                                           scale_ms:
                                                               cass_uint64_t,
                                                           retry_period_ms:
                                                               cass_uint64_t,
                                                           update_rate_ms:
                                                               cass_uint64_t,
                                                           min_measured:
                                                               cass_uint64_t);
    pub fn cass_cluster_set_whitelist_filtering(cluster: *mut CassCluster,
                                                hosts:
                                                    *const ::std::os::raw::c_char);
    pub fn cass_cluster_set_whitelist_filtering_n(cluster: *mut CassCluster,
                                                  hosts:
                                                      *const ::std::os::raw::c_char,
                                                  hosts_length: size_t);
    pub fn cass_cluster_set_blacklist_filtering(cluster: *mut CassCluster,
                                                hosts:
                                                    *const ::std::os::raw::c_char);
    pub fn cass_cluster_set_blacklist_filtering_n(cluster: *mut CassCluster,
                                                  hosts:
                                                      *const ::std::os::raw::c_char,
                                                  hosts_length: size_t);
    pub fn cass_cluster_set_whitelist_dc_filtering(cluster: *mut CassCluster,
                                                   dcs:
                                                       *const ::std::os::raw::c_char);
    pub fn cass_cluster_set_whitelist_dc_filtering_n(cluster:
                                                         *mut CassCluster,
                                                     dcs:
                                                         *const ::std::os::raw::c_char,
                                                     dcs_length: size_t);
    pub fn cass_cluster_set_blacklist_dc_filtering(cluster: *mut CassCluster,
                                                   dcs:
                                                       *const ::std::os::raw::c_char);
    pub fn cass_cluster_set_blacklist_dc_filtering_n(cluster:
                                                         *mut CassCluster,
                                                     dcs:
                                                         *const ::std::os::raw::c_char,
                                                     dcs_length: size_t);
    pub fn cass_cluster_set_tcp_nodelay(cluster: *mut CassCluster,
                                        enabled: cass_bool_t);
    pub fn cass_cluster_set_tcp_keepalive(cluster: *mut CassCluster,
                                          enabled: cass_bool_t,
                                          delay_secs: ::std::os::raw::c_uint);
    pub fn cass_cluster_set_timestamp_gen(cluster: *mut CassCluster,
                                          timestamp_gen:
                                              *mut CassTimestampGen);
    pub fn cass_cluster_set_connection_heartbeat_interval(cluster:
                                                              *mut CassCluster,
                                                          interval_secs:
                                                              ::std::os::raw::c_uint);
    pub fn cass_cluster_set_connection_idle_timeout(cluster: *mut CassCluster,
                                                    timeout_secs:
                                                        ::std::os::raw::c_uint);
    pub fn cass_cluster_set_retry_policy(cluster: *mut CassCluster,
                                         retry_policy: *mut CassRetryPolicy);
    pub fn cass_cluster_set_use_schema(cluster: *mut CassCluster,
                                       enabled: cass_bool_t);
    pub fn cass_cluster_set_use_hostname_resolution(cluster: *mut CassCluster,
                                                    enabled: cass_bool_t)
     -> CassError;
    pub fn cass_cluster_set_use_randomized_contact_points(cluster:
                                                              *mut CassCluster,
                                                          enabled:
                                                              cass_bool_t)
     -> CassError;
    pub fn cass_session_new() -> *mut CassSession;
    pub fn cass_session_free(session: *mut CassSession);
    pub fn cass_session_connect(session: *mut CassSession,
                                cluster: *const CassCluster)
     -> *mut CassFuture;
    pub fn cass_session_connect_keyspace(session: *mut CassSession,
                                         cluster: *const CassCluster,
                                         keyspace:
                                             *const ::std::os::raw::c_char)
     -> *mut CassFuture;
    pub fn cass_session_connect_keyspace_n(session: *mut CassSession,
                                           cluster: *const CassCluster,
                                           keyspace:
                                               *const ::std::os::raw::c_char,
                                           keyspace_length: size_t)
     -> *mut CassFuture;
    pub fn cass_session_close(session: *mut CassSession) -> *mut CassFuture;
    pub fn cass_session_prepare(session: *mut CassSession,
                                query: *const ::std::os::raw::c_char)
     -> *mut CassFuture;
    pub fn cass_session_prepare_n(session: *mut CassSession,
                                  query: *const ::std::os::raw::c_char,
                                  query_length: size_t) -> *mut CassFuture;
    pub fn cass_session_execute(session: *mut CassSession,
                                statement: *const CassStatement)
     -> *mut CassFuture;
    pub fn cass_session_execute_batch(session: *mut CassSession,
                                      batch: *const CassBatch)
     -> *mut CassFuture;
    pub fn cass_session_get_schema_meta(session: *const CassSession)
     -> *const CassSchemaMeta;
    pub fn cass_session_get_metrics(session: *const CassSession,
                                    output: *mut CassMetrics);
    pub fn cass_schema_meta_free(schema_meta: *const CassSchemaMeta);
    pub fn cass_schema_meta_snapshot_version(schema_meta:
                                                 *const CassSchemaMeta)
     -> cass_uint32_t;
    pub fn cass_schema_meta_version(schema_meta: *const CassSchemaMeta)
     -> CassVersion;
    pub fn cass_schema_meta_keyspace_by_name(schema_meta:
                                                 *const CassSchemaMeta,
                                             keyspace:
                                                 *const ::std::os::raw::c_char)
     -> *const CassKeyspaceMeta;
    pub fn cass_schema_meta_keyspace_by_name_n(schema_meta:
                                                   *const CassSchemaMeta,
                                               keyspace:
                                                   *const ::std::os::raw::c_char,
                                               keyspace_length: size_t)
     -> *const CassKeyspaceMeta;
    pub fn cass_keyspace_meta_name(keyspace_meta: *const CassKeyspaceMeta,
                                   name: *mut *const ::std::os::raw::c_char,
                                   name_length: *mut size_t);
    pub fn cass_keyspace_meta_table_by_name(keyspace_meta:
                                                *const CassKeyspaceMeta,
                                            table:
                                                *const ::std::os::raw::c_char)
     -> *const CassTableMeta;
    pub fn cass_keyspace_meta_table_by_name_n(keyspace_meta:
                                                  *const CassKeyspaceMeta,
                                              table:
                                                  *const ::std::os::raw::c_char,
                                              table_length: size_t)
     -> *const CassTableMeta;
    pub fn cass_keyspace_meta_materialized_view_by_name(keyspace_meta:
                                                            *const CassKeyspaceMeta,
                                                        view:
                                                            *const ::std::os::raw::c_char)
     -> *const CassMaterializedViewMeta;
    pub fn cass_keyspace_meta_materialized_view_by_name_n(keyspace_meta:
                                                              *const CassKeyspaceMeta,
                                                          view:
                                                              *const ::std::os::raw::c_char,
                                                          view_length: size_t)
     -> *const CassMaterializedViewMeta;
    pub fn cass_keyspace_meta_user_type_by_name(keyspace_meta:
                                                    *const CassKeyspaceMeta,
                                                type_:
                                                    *const ::std::os::raw::c_char)
     -> *const CassDataType;
    pub fn cass_keyspace_meta_user_type_by_name_n(keyspace_meta:
                                                      *const CassKeyspaceMeta,
                                                  type_:
                                                      *const ::std::os::raw::c_char,
                                                  type_length: size_t)
     -> *const CassDataType;
    pub fn cass_keyspace_meta_function_by_name(keyspace_meta:
                                                   *const CassKeyspaceMeta,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               arguments:
                                                   *const ::std::os::raw::c_char)
     -> *const CassFunctionMeta;
    pub fn cass_keyspace_meta_function_by_name_n(keyspace_meta:
                                                     *const CassKeyspaceMeta,
                                                 name:
                                                     *const ::std::os::raw::c_char,
                                                 name_length: size_t,
                                                 arguments:
                                                     *const ::std::os::raw::c_char,
                                                 arguments_length: size_t)
     -> *const CassFunctionMeta;
    pub fn cass_keyspace_meta_aggregate_by_name(keyspace_meta:
                                                    *const CassKeyspaceMeta,
                                                name:
                                                    *const ::std::os::raw::c_char,
                                                arguments:
                                                    *const ::std::os::raw::c_char)
     -> *const CassAggregateMeta;
    pub fn cass_keyspace_meta_aggregate_by_name_n(keyspace_meta:
                                                      *const CassKeyspaceMeta,
                                                  name:
                                                      *const ::std::os::raw::c_char,
                                                  name_length: size_t,
                                                  arguments:
                                                      *const ::std::os::raw::c_char,
                                                  arguments_length: size_t)
     -> *const CassAggregateMeta;
    pub fn cass_keyspace_meta_field_by_name(keyspace_meta:
                                                *const CassKeyspaceMeta,
                                            name:
                                                *const ::std::os::raw::c_char)
     -> *const CassValue;
    pub fn cass_keyspace_meta_field_by_name_n(keyspace_meta:
                                                  *const CassKeyspaceMeta,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t)
     -> *const CassValue;
    pub fn cass_table_meta_name(table_meta: *const CassTableMeta,
                                name: *mut *const ::std::os::raw::c_char,
                                name_length: *mut size_t);
    pub fn cass_table_meta_column_by_name(table_meta: *const CassTableMeta,
                                          column:
                                              *const ::std::os::raw::c_char)
     -> *const CassColumnMeta;
    pub fn cass_table_meta_column_by_name_n(table_meta: *const CassTableMeta,
                                            column:
                                                *const ::std::os::raw::c_char,
                                            column_length: size_t)
     -> *const CassColumnMeta;
    pub fn cass_table_meta_column_count(table_meta: *const CassTableMeta)
     -> size_t;
    pub fn cass_table_meta_column(table_meta: *const CassTableMeta,
                                  index: size_t) -> *const CassColumnMeta;
    pub fn cass_table_meta_index_by_name(table_meta: *const CassTableMeta,
                                         index: *const ::std::os::raw::c_char)
     -> *const CassIndexMeta;
    pub fn cass_table_meta_index_by_name_n(table_meta: *const CassTableMeta,
                                           index:
                                               *const ::std::os::raw::c_char,
                                           index_length: size_t)
     -> *const CassIndexMeta;
    pub fn cass_table_meta_index_count(table_meta: *const CassTableMeta)
     -> size_t;
    pub fn cass_table_meta_index(table_meta: *const CassTableMeta,
                                 index: size_t) -> *const CassIndexMeta;
    pub fn cass_table_meta_materialized_view_by_name(table_meta:
                                                         *const CassTableMeta,
                                                     view:
                                                         *const ::std::os::raw::c_char)
     -> *const CassMaterializedViewMeta;
    pub fn cass_table_meta_materialized_view_by_name_n(table_meta:
                                                           *const CassTableMeta,
                                                       view:
                                                           *const ::std::os::raw::c_char,
                                                       view_length: size_t)
     -> *const CassMaterializedViewMeta;
    pub fn cass_table_meta_materialized_view_count(table_meta:
                                                       *const CassTableMeta)
     -> size_t;
    pub fn cass_table_meta_materialized_view(table_meta: *const CassTableMeta,
                                             index: size_t)
     -> *const CassMaterializedViewMeta;
    pub fn cass_table_meta_partition_key_count(table_meta:
                                                   *const CassTableMeta)
     -> size_t;
    pub fn cass_table_meta_partition_key(table_meta: *const CassTableMeta,
                                         index: size_t)
     -> *const CassColumnMeta;
    pub fn cass_table_meta_clustering_key_count(table_meta:
                                                    *const CassTableMeta)
     -> size_t;
    pub fn cass_table_meta_clustering_key(table_meta: *const CassTableMeta,
                                          index: size_t)
     -> *const CassColumnMeta;
    pub fn cass_table_meta_clustering_key_order(table_meta:
                                                    *const CassTableMeta,
                                                index: size_t)
     -> CassClusteringOrder;
    pub fn cass_table_meta_field_by_name(table_meta: *const CassTableMeta,
                                         name: *const ::std::os::raw::c_char)
     -> *const CassValue;
    pub fn cass_table_meta_field_by_name_n(table_meta: *const CassTableMeta,
                                           name:
                                               *const ::std::os::raw::c_char,
                                           name_length: size_t)
     -> *const CassValue;
    pub fn cass_materialized_view_meta_column_by_name(view_meta:
                                                          *const CassMaterializedViewMeta,
                                                      column:
                                                          *const ::std::os::raw::c_char)
     -> *const CassColumnMeta;
    pub fn cass_materialized_view_meta_column_by_name_n(view_meta:
                                                            *const CassMaterializedViewMeta,
                                                        column:
                                                            *const ::std::os::raw::c_char,
                                                        column_length: size_t)
     -> *const CassColumnMeta;
    pub fn cass_materialized_view_meta_name(view_meta:
                                                *const CassMaterializedViewMeta,
                                            name:
                                                *mut *const ::std::os::raw::c_char,
                                            name_length: *mut size_t);
    pub fn cass_materialized_view_meta_base_table(view_meta:
                                                      *const CassMaterializedViewMeta)
     -> *const CassTableMeta;
    pub fn cass_materialized_view_meta_column_count(view_meta:
                                                        *const CassMaterializedViewMeta)
     -> size_t;
    pub fn cass_materialized_view_meta_column(view_meta:
                                                  *const CassMaterializedViewMeta,
                                              index: size_t)
     -> *const CassColumnMeta;
    pub fn cass_materialized_view_meta_partition_key_count(view_meta:
                                                               *const CassMaterializedViewMeta)
     -> size_t;
    pub fn cass_materialized_view_meta_partition_key(view_meta:
                                                         *const CassMaterializedViewMeta,
                                                     index: size_t)
     -> *const CassColumnMeta;
    pub fn cass_materialized_view_meta_clustering_key_count(view_meta:
                                                                *const CassMaterializedViewMeta)
     -> size_t;
    pub fn cass_materialized_view_meta_clustering_key(view_meta:
                                                          *const CassMaterializedViewMeta,
                                                      index: size_t)
     -> *const CassColumnMeta;
    pub fn cass_materialized_view_meta_clustering_key_order(view_meta:
                                                                *const CassMaterializedViewMeta,
                                                            index: size_t)
     -> CassClusteringOrder;
    pub fn cass_materialized_view_meta_field_by_name(view_meta:
                                                         *const CassMaterializedViewMeta,
                                                     name:
                                                         *const ::std::os::raw::c_char)
     -> *const CassValue;
    pub fn cass_materialized_view_meta_field_by_name_n(view_meta:
                                                           *const CassMaterializedViewMeta,
                                                       name:
                                                           *const ::std::os::raw::c_char,
                                                       name_length: size_t)
     -> *const CassValue;
    pub fn cass_column_meta_name(column_meta: *const CassColumnMeta,
                                 name: *mut *const ::std::os::raw::c_char,
                                 name_length: *mut size_t);
    pub fn cass_column_meta_type(column_meta: *const CassColumnMeta)
     -> CassColumnType;
    pub fn cass_column_meta_data_type(column_meta: *const CassColumnMeta)
     -> *const CassDataType;
    pub fn cass_column_meta_field_by_name(column_meta: *const CassColumnMeta,
                                          name: *const ::std::os::raw::c_char)
     -> *const CassValue;
    pub fn cass_column_meta_field_by_name_n(column_meta:
                                                *const CassColumnMeta,
                                            name:
                                                *const ::std::os::raw::c_char,
                                            name_length: size_t)
     -> *const CassValue;
    pub fn cass_index_meta_name(index_meta: *const CassIndexMeta,
                                name: *mut *const ::std::os::raw::c_char,
                                name_length: *mut size_t);
    pub fn cass_index_meta_type(index_meta: *const CassIndexMeta)
     -> CassIndexType;
    pub fn cass_index_meta_target(index_meta: *const CassIndexMeta,
                                  target: *mut *const ::std::os::raw::c_char,
                                  target_length: *mut size_t);
    pub fn cass_index_meta_options(index_meta: *const CassIndexMeta)
     -> *const CassValue;
    pub fn cass_index_meta_field_by_name(index_meta: *const CassIndexMeta,
                                         name: *const ::std::os::raw::c_char)
     -> *const CassValue;
    pub fn cass_index_meta_field_by_name_n(index_meta: *const CassIndexMeta,
                                           name:
                                               *const ::std::os::raw::c_char,
                                           name_length: size_t)
     -> *const CassValue;
    pub fn cass_function_meta_name(function_meta: *const CassFunctionMeta,
                                   name: *mut *const ::std::os::raw::c_char,
                                   name_length: *mut size_t);
    pub fn cass_function_meta_full_name(function_meta:
                                            *const CassFunctionMeta,
                                        full_name:
                                            *mut *const ::std::os::raw::c_char,
                                        full_name_length: *mut size_t);
    pub fn cass_function_meta_body(function_meta: *const CassFunctionMeta,
                                   body: *mut *const ::std::os::raw::c_char,
                                   body_length: *mut size_t);
    pub fn cass_function_meta_language(function_meta: *const CassFunctionMeta,
                                       language:
                                           *mut *const ::std::os::raw::c_char,
                                       language_length: *mut size_t);
    pub fn cass_function_meta_called_on_null_input(function_meta:
                                                       *const CassFunctionMeta)
     -> cass_bool_t;
    pub fn cass_function_meta_argument_count(function_meta:
                                                 *const CassFunctionMeta)
     -> size_t;
    pub fn cass_function_meta_argument(function_meta: *const CassFunctionMeta,
                                       index: size_t,
                                       name:
                                           *mut *const ::std::os::raw::c_char,
                                       name_length: *mut size_t,
                                       type_: *mut *const CassDataType)
     -> CassError;
    pub fn cass_function_meta_argument_type_by_name(function_meta:
                                                        *const CassFunctionMeta,
                                                    name:
                                                        *const ::std::os::raw::c_char)
     -> *const CassDataType;
    pub fn cass_function_meta_argument_type_by_name_n(function_meta:
                                                          *const CassFunctionMeta,
                                                      name:
                                                          *const ::std::os::raw::c_char,
                                                      name_length: size_t)
     -> *const CassDataType;
    pub fn cass_function_meta_return_type(function_meta:
                                              *const CassFunctionMeta)
     -> *const CassDataType;
    pub fn cass_function_meta_field_by_name(function_meta:
                                                *const CassFunctionMeta,
                                            name:
                                                *const ::std::os::raw::c_char)
     -> *const CassValue;
    pub fn cass_function_meta_field_by_name_n(function_meta:
                                                  *const CassFunctionMeta,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t)
     -> *const CassValue;
    pub fn cass_aggregate_meta_name(aggregate_meta: *const CassAggregateMeta,
                                    name: *mut *const ::std::os::raw::c_char,
                                    name_length: *mut size_t);
    pub fn cass_aggregate_meta_full_name(aggregate_meta:
                                             *const CassAggregateMeta,
                                         full_name:
                                             *mut *const ::std::os::raw::c_char,
                                         full_name_length: *mut size_t);
    pub fn cass_aggregate_meta_argument_count(aggregate_meta:
                                                  *const CassAggregateMeta)
     -> size_t;
    pub fn cass_aggregate_meta_argument_type(aggregate_meta:
                                                 *const CassAggregateMeta,
                                             index: size_t)
     -> *const CassDataType;
    pub fn cass_aggregate_meta_return_type(aggregate_meta:
                                               *const CassAggregateMeta)
     -> *const CassDataType;
    pub fn cass_aggregate_meta_state_type(aggregate_meta:
                                              *const CassAggregateMeta)
     -> *const CassDataType;
    pub fn cass_aggregate_meta_state_func(aggregate_meta:
                                              *const CassAggregateMeta)
     -> *const CassFunctionMeta;
    pub fn cass_aggregate_meta_final_func(aggregate_meta:
                                              *const CassAggregateMeta)
     -> *const CassFunctionMeta;
    pub fn cass_aggregate_meta_init_cond(aggregate_meta:
                                             *const CassAggregateMeta)
     -> *const CassValue;
    pub fn cass_aggregate_meta_field_by_name(aggregate_meta:
                                                 *const CassAggregateMeta,
                                             name:
                                                 *const ::std::os::raw::c_char)
     -> *const CassValue;
    pub fn cass_aggregate_meta_field_by_name_n(aggregate_meta:
                                                   *const CassAggregateMeta,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               name_length: size_t)
     -> *const CassValue;
    pub fn cass_ssl_new() -> *mut CassSsl;
    pub fn cass_ssl_free(ssl: *mut CassSsl);
    pub fn cass_ssl_add_trusted_cert(ssl: *mut CassSsl,
                                     cert: *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_ssl_add_trusted_cert_n(ssl: *mut CassSsl,
                                       cert: *const ::std::os::raw::c_char,
                                       cert_length: size_t) -> CassError;
    pub fn cass_ssl_set_verify_flags(ssl: *mut CassSsl,
                                     flags: ::std::os::raw::c_int);
    pub fn cass_ssl_set_cert(ssl: *mut CassSsl,
                             cert: *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_ssl_set_cert_n(ssl: *mut CassSsl,
                               cert: *const ::std::os::raw::c_char,
                               cert_length: size_t) -> CassError;
    pub fn cass_ssl_set_private_key(ssl: *mut CassSsl,
                                    key: *const ::std::os::raw::c_char,
                                    password: *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_ssl_set_private_key_n(ssl: *mut CassSsl,
                                      key: *const ::std::os::raw::c_char,
                                      key_length: size_t,
                                      password: *const ::std::os::raw::c_char,
                                      password_length: size_t) -> CassError;
    pub fn cass_authenticator_address(auth: *const CassAuthenticator,
                                      address: *mut CassInet);
    pub fn cass_authenticator_hostname(auth: *const CassAuthenticator,
                                       length: *mut size_t)
     -> *const ::std::os::raw::c_char;
    pub fn cass_authenticator_class_name(auth: *const CassAuthenticator,
                                         length: *mut size_t)
     -> *const ::std::os::raw::c_char;
    pub fn cass_authenticator_exchange_data(auth: *mut CassAuthenticator)
     -> *mut ::std::os::raw::c_void;
    pub fn cass_authenticator_set_exchange_data(auth: *mut CassAuthenticator,
                                                exchange_data:
                                                    *mut ::std::os::raw::c_void);
    pub fn cass_authenticator_response(auth: *mut CassAuthenticator,
                                       size: size_t)
     -> *mut ::std::os::raw::c_char;
    pub fn cass_authenticator_set_response(auth: *mut CassAuthenticator,
                                           response:
                                               *const ::std::os::raw::c_char,
                                           response_size: size_t);
    pub fn cass_authenticator_set_error(auth: *mut CassAuthenticator,
                                        message:
                                            *const ::std::os::raw::c_char);
    pub fn cass_authenticator_set_error_n(auth: *mut CassAuthenticator,
                                          message:
                                              *const ::std::os::raw::c_char,
                                          message_length: size_t);
    pub fn cass_future_free(future: *mut CassFuture);
    pub fn cass_future_set_callback(future: *mut CassFuture,
                                    callback: CassFutureCallback,
                                    data: *mut ::std::os::raw::c_void)
     -> CassError;
    pub fn cass_future_ready(future: *mut CassFuture) -> cass_bool_t;
    pub fn cass_future_wait(future: *mut CassFuture);
    pub fn cass_future_wait_timed(future: *mut CassFuture,
                                  timeout_us: cass_duration_t) -> cass_bool_t;
    pub fn cass_future_get_result(future: *mut CassFuture)
     -> *const CassResult;
    pub fn cass_future_get_error_result(future: *mut CassFuture)
     -> *const CassErrorResult;
    pub fn cass_future_get_prepared(future: *mut CassFuture)
     -> *const CassPrepared;
    pub fn cass_future_error_code(future: *mut CassFuture) -> CassError;
    pub fn cass_future_error_message(future: *mut CassFuture,
                                     message:
                                         *mut *const ::std::os::raw::c_char,
                                     message_length: *mut size_t);
    pub fn cass_future_custom_payload_item_count(future: *mut CassFuture)
     -> size_t;
    pub fn cass_future_custom_payload_item(future: *mut CassFuture,
                                           index: size_t,
                                           name:
                                               *mut *const ::std::os::raw::c_char,
                                           name_length: *mut size_t,
                                           value: *mut *const cass_byte_t,
                                           value_size: *mut size_t)
     -> CassError;
    pub fn cass_statement_new(query: *const ::std::os::raw::c_char,
                              parameter_count: size_t) -> *mut CassStatement;
    pub fn cass_statement_new_n(query: *const ::std::os::raw::c_char,
                                query_length: size_t, parameter_count: size_t)
     -> *mut CassStatement;
    pub fn cass_statement_reset_parameters(statement: *mut CassStatement,
                                           count: size_t) -> CassError;
    pub fn cass_statement_free(statement: *mut CassStatement);
    pub fn cass_statement_add_key_index(statement: *mut CassStatement,
                                        index: size_t) -> CassError;
    pub fn cass_statement_set_keyspace(statement: *mut CassStatement,
                                       keyspace:
                                           *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_statement_set_keyspace_n(statement: *mut CassStatement,
                                         keyspace:
                                             *const ::std::os::raw::c_char,
                                         keyspace_length: size_t)
     -> CassError;
    pub fn cass_statement_set_consistency(statement: *mut CassStatement,
                                          consistency: CassConsistency)
     -> CassError;
    pub fn cass_statement_set_serial_consistency(statement:
                                                     *mut CassStatement,
                                                 serial_consistency:
                                                     CassConsistency)
     -> CassError;
    pub fn cass_statement_set_paging_size(statement: *mut CassStatement,
                                          page_size: ::std::os::raw::c_int)
     -> CassError;
    pub fn cass_statement_set_paging_state(statement: *mut CassStatement,
                                           result: *const CassResult)
     -> CassError;
    pub fn cass_statement_set_paging_state_token(statement:
                                                     *mut CassStatement,
                                                 paging_state:
                                                     *const ::std::os::raw::c_char,
                                                 paging_state_size: size_t)
     -> CassError;
    pub fn cass_statement_set_timestamp(statement: *mut CassStatement,
                                        timestamp: cass_int64_t) -> CassError;
    pub fn cass_statement_set_request_timeout(statement: *mut CassStatement,
                                              timeout_ms: cass_uint64_t)
     -> CassError;
    pub fn cass_statement_set_retry_policy(statement: *mut CassStatement,
                                           retry_policy: *mut CassRetryPolicy)
     -> CassError;
    pub fn cass_statement_set_custom_payload(statement: *mut CassStatement,
                                             payload:
                                                 *const CassCustomPayload)
     -> CassError;
    pub fn cass_statement_bind_null(statement: *mut CassStatement,
                                    index: size_t) -> CassError;
    pub fn cass_statement_bind_null_by_name(statement: *mut CassStatement,
                                            name:
                                                *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_statement_bind_null_by_name_n(statement: *mut CassStatement,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t)
     -> CassError;
    pub fn cass_statement_bind_int8(statement: *mut CassStatement,
                                    index: size_t, value: cass_int8_t)
     -> CassError;
    pub fn cass_statement_bind_int8_by_name(statement: *mut CassStatement,
                                            name:
                                                *const ::std::os::raw::c_char,
                                            value: cass_int8_t) -> CassError;
    pub fn cass_statement_bind_int8_by_name_n(statement: *mut CassStatement,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t,
                                              value: cass_int8_t)
     -> CassError;
    pub fn cass_statement_bind_int16(statement: *mut CassStatement,
                                     index: size_t, value: cass_int16_t)
     -> CassError;
    pub fn cass_statement_bind_int16_by_name(statement: *mut CassStatement,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             value: cass_int16_t)
     -> CassError;
    pub fn cass_statement_bind_int16_by_name_n(statement: *mut CassStatement,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               name_length: size_t,
                                               value: cass_int16_t)
     -> CassError;
    pub fn cass_statement_bind_int32(statement: *mut CassStatement,
                                     index: size_t, value: cass_int32_t)
     -> CassError;
    pub fn cass_statement_bind_int32_by_name(statement: *mut CassStatement,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             value: cass_int32_t)
     -> CassError;
    pub fn cass_statement_bind_int32_by_name_n(statement: *mut CassStatement,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               name_length: size_t,
                                               value: cass_int32_t)
     -> CassError;
    pub fn cass_statement_bind_uint32(statement: *mut CassStatement,
                                      index: size_t, value: cass_uint32_t)
     -> CassError;
    pub fn cass_statement_bind_uint32_by_name(statement: *mut CassStatement,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              value: cass_uint32_t)
     -> CassError;
    pub fn cass_statement_bind_uint32_by_name_n(statement: *mut CassStatement,
                                                name:
                                                    *const ::std::os::raw::c_char,
                                                name_length: size_t,
                                                value: cass_uint32_t)
     -> CassError;
    pub fn cass_statement_bind_int64(statement: *mut CassStatement,
                                     index: size_t, value: cass_int64_t)
     -> CassError;
    pub fn cass_statement_bind_int64_by_name(statement: *mut CassStatement,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             value: cass_int64_t)
     -> CassError;
    pub fn cass_statement_bind_int64_by_name_n(statement: *mut CassStatement,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               name_length: size_t,
                                               value: cass_int64_t)
     -> CassError;
    pub fn cass_statement_bind_float(statement: *mut CassStatement,
                                     index: size_t, value: cass_float_t)
     -> CassError;
    pub fn cass_statement_bind_float_by_name(statement: *mut CassStatement,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             value: cass_float_t)
     -> CassError;
    pub fn cass_statement_bind_float_by_name_n(statement: *mut CassStatement,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               name_length: size_t,
                                               value: cass_float_t)
     -> CassError;
    pub fn cass_statement_bind_double(statement: *mut CassStatement,
                                      index: size_t, value: cass_double_t)
     -> CassError;
    pub fn cass_statement_bind_double_by_name(statement: *mut CassStatement,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              value: cass_double_t)
     -> CassError;
    pub fn cass_statement_bind_double_by_name_n(statement: *mut CassStatement,
                                                name:
                                                    *const ::std::os::raw::c_char,
                                                name_length: size_t,
                                                value: cass_double_t)
     -> CassError;
    pub fn cass_statement_bind_bool(statement: *mut CassStatement,
                                    index: size_t, value: cass_bool_t)
     -> CassError;
    pub fn cass_statement_bind_bool_by_name(statement: *mut CassStatement,
                                            name:
                                                *const ::std::os::raw::c_char,
                                            value: cass_bool_t) -> CassError;
    pub fn cass_statement_bind_bool_by_name_n(statement: *mut CassStatement,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t,
                                              value: cass_bool_t)
     -> CassError;
    pub fn cass_statement_bind_string(statement: *mut CassStatement,
                                      index: size_t,
                                      value: *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_statement_bind_string_n(statement: *mut CassStatement,
                                        index: size_t,
                                        value: *const ::std::os::raw::c_char,
                                        value_length: size_t) -> CassError;
    pub fn cass_statement_bind_string_by_name(statement: *mut CassStatement,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              value:
                                                  *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_statement_bind_string_by_name_n(statement: *mut CassStatement,
                                                name:
                                                    *const ::std::os::raw::c_char,
                                                name_length: size_t,
                                                value:
                                                    *const ::std::os::raw::c_char,
                                                value_length: size_t)
     -> CassError;
    pub fn cass_statement_bind_bytes(statement: *mut CassStatement,
                                     index: size_t, value: *const cass_byte_t,
                                     value_size: size_t) -> CassError;
    pub fn cass_statement_bind_bytes_by_name(statement: *mut CassStatement,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             value: *const cass_byte_t,
                                             value_size: size_t) -> CassError;
    pub fn cass_statement_bind_bytes_by_name_n(statement: *mut CassStatement,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               name_length: size_t,
                                               value: *const cass_byte_t,
                                               value_size: size_t)
     -> CassError;
    pub fn cass_statement_bind_custom(statement: *mut CassStatement,
                                      index: size_t,
                                      class_name:
                                          *const ::std::os::raw::c_char,
                                      value: *const cass_byte_t,
                                      value_size: size_t) -> CassError;
    pub fn cass_statement_bind_custom_n(statement: *mut CassStatement,
                                        index: size_t,
                                        class_name:
                                            *const ::std::os::raw::c_char,
                                        class_name_length: size_t,
                                        value: *const cass_byte_t,
                                        value_size: size_t) -> CassError;
    pub fn cass_statement_bind_custom_by_name(statement: *mut CassStatement,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              class_name:
                                                  *const ::std::os::raw::c_char,
                                              value: *const cass_byte_t,
                                              value_size: size_t)
     -> CassError;
    pub fn cass_statement_bind_custom_by_name_n(statement: *mut CassStatement,
                                                name:
                                                    *const ::std::os::raw::c_char,
                                                name_length: size_t,
                                                class_name:
                                                    *const ::std::os::raw::c_char,
                                                class_name_length: size_t,
                                                value: *const cass_byte_t,
                                                value_size: size_t)
     -> CassError;
    pub fn cass_statement_bind_uuid(statement: *mut CassStatement,
                                    index: size_t, value: CassUuid)
     -> CassError;
    pub fn cass_statement_bind_uuid_by_name(statement: *mut CassStatement,
                                            name:
                                                *const ::std::os::raw::c_char,
                                            value: CassUuid) -> CassError;
    pub fn cass_statement_bind_uuid_by_name_n(statement: *mut CassStatement,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t,
                                              value: CassUuid) -> CassError;
    pub fn cass_statement_bind_inet(statement: *mut CassStatement,
                                    index: size_t, value: CassInet)
     -> CassError;
    pub fn cass_statement_bind_inet_by_name(statement: *mut CassStatement,
                                            name:
                                                *const ::std::os::raw::c_char,
                                            value: CassInet) -> CassError;
    pub fn cass_statement_bind_inet_by_name_n(statement: *mut CassStatement,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t,
                                              value: CassInet) -> CassError;
    pub fn cass_statement_bind_decimal(statement: *mut CassStatement,
                                       index: size_t,
                                       varint: *const cass_byte_t,
                                       varint_size: size_t,
                                       scale: cass_int32_t) -> CassError;
    pub fn cass_statement_bind_decimal_by_name(statement: *mut CassStatement,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               varint: *const cass_byte_t,
                                               varint_size: size_t,
                                               scale: cass_int32_t)
     -> CassError;
    pub fn cass_statement_bind_decimal_by_name_n(statement:
                                                     *mut CassStatement,
                                                 name:
                                                     *const ::std::os::raw::c_char,
                                                 name_length: size_t,
                                                 varint: *const cass_byte_t,
                                                 varint_size: size_t,
                                                 scale: cass_int32_t)
     -> CassError;
    pub fn cass_statement_bind_collection(statement: *mut CassStatement,
                                          index: size_t,
                                          collection: *const CassCollection)
     -> CassError;
    pub fn cass_statement_bind_collection_by_name(statement:
                                                      *mut CassStatement,
                                                  name:
                                                      *const ::std::os::raw::c_char,
                                                  collection:
                                                      *const CassCollection)
     -> CassError;
    pub fn cass_statement_bind_collection_by_name_n(statement:
                                                        *mut CassStatement,
                                                    name:
                                                        *const ::std::os::raw::c_char,
                                                    name_length: size_t,
                                                    collection:
                                                        *const CassCollection)
     -> CassError;
    pub fn cass_statement_bind_tuple(statement: *mut CassStatement,
                                     index: size_t, tuple: *const CassTuple)
     -> CassError;
    pub fn cass_statement_bind_tuple_by_name(statement: *mut CassStatement,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             tuple: *const CassTuple)
     -> CassError;
    pub fn cass_statement_bind_tuple_by_name_n(statement: *mut CassStatement,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               name_length: size_t,
                                               tuple: *const CassTuple)
     -> CassError;
    pub fn cass_statement_bind_user_type(statement: *mut CassStatement,
                                         index: size_t,
                                         user_type: *const CassUserType)
     -> CassError;
    pub fn cass_statement_bind_user_type_by_name(statement:
                                                     *mut CassStatement,
                                                 name:
                                                     *const ::std::os::raw::c_char,
                                                 user_type:
                                                     *const CassUserType)
     -> CassError;
    pub fn cass_statement_bind_user_type_by_name_n(statement:
                                                       *mut CassStatement,
                                                   name:
                                                       *const ::std::os::raw::c_char,
                                                   name_length: size_t,
                                                   user_type:
                                                       *const CassUserType)
     -> CassError;
    pub fn cass_prepared_free(prepared: *const CassPrepared);
    pub fn cass_prepared_bind(prepared: *const CassPrepared)
     -> *mut CassStatement;
    pub fn cass_prepared_parameter_name(prepared: *const CassPrepared,
                                        index: size_t,
                                        name:
                                            *mut *const ::std::os::raw::c_char,
                                        name_length: *mut size_t)
     -> CassError;
    pub fn cass_prepared_parameter_data_type(prepared: *const CassPrepared,
                                             index: size_t)
     -> *const CassDataType;
    pub fn cass_prepared_parameter_data_type_by_name(prepared:
                                                         *const CassPrepared,
                                                     name:
                                                         *const ::std::os::raw::c_char)
     -> *const CassDataType;
    pub fn cass_prepared_parameter_data_type_by_name_n(prepared:
                                                           *const CassPrepared,
                                                       name:
                                                           *const ::std::os::raw::c_char,
                                                       name_length: size_t)
     -> *const CassDataType;
    pub fn cass_batch_new(type_: CassBatchType) -> *mut CassBatch;
    pub fn cass_batch_free(batch: *mut CassBatch);
    pub fn cass_batch_set_consistency(batch: *mut CassBatch,
                                      consistency: CassConsistency)
     -> CassError;
    pub fn cass_batch_set_serial_consistency(batch: *mut CassBatch,
                                             serial_consistency:
                                                 CassConsistency)
     -> CassError;
    pub fn cass_batch_set_timestamp(batch: *mut CassBatch,
                                    timestamp: cass_int64_t) -> CassError;
    pub fn cass_batch_set_request_timeout(batch: *mut CassBatch,
                                          timeout_ms: cass_uint64_t)
     -> CassError;
    pub fn cass_batch_set_retry_policy(batch: *mut CassBatch,
                                       retry_policy: *mut CassRetryPolicy)
     -> CassError;
    pub fn cass_batch_set_custom_payload(batch: *mut CassBatch,
                                         payload: *const CassCustomPayload)
     -> CassError;
    pub fn cass_batch_add_statement(batch: *mut CassBatch,
                                    statement: *mut CassStatement)
     -> CassError;
    pub fn cass_data_type_new(type_: CassValueType) -> *mut CassDataType;
    pub fn cass_data_type_new_from_existing(data_type: *const CassDataType)
     -> *mut CassDataType;
    pub fn cass_data_type_new_tuple(item_count: size_t) -> *mut CassDataType;
    pub fn cass_data_type_new_udt(field_count: size_t) -> *mut CassDataType;
    pub fn cass_data_type_free(data_type: *mut CassDataType);
    pub fn cass_data_type_type(data_type: *const CassDataType)
     -> CassValueType;
    pub fn cass_data_type_is_frozen(data_type: *const CassDataType)
     -> cass_bool_t;
    pub fn cass_data_type_type_name(data_type: *const CassDataType,
                                    type_name:
                                        *mut *const ::std::os::raw::c_char,
                                    type_name_length: *mut size_t)
     -> CassError;
    pub fn cass_data_type_set_type_name(data_type: *mut CassDataType,
                                        type_name:
                                            *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_data_type_set_type_name_n(data_type: *mut CassDataType,
                                          type_name:
                                              *const ::std::os::raw::c_char,
                                          type_name_length: size_t)
     -> CassError;
    pub fn cass_data_type_keyspace(data_type: *const CassDataType,
                                   keyspace:
                                       *mut *const ::std::os::raw::c_char,
                                   keyspace_length: *mut size_t) -> CassError;
    pub fn cass_data_type_set_keyspace(data_type: *mut CassDataType,
                                       keyspace:
                                           *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_data_type_set_keyspace_n(data_type: *mut CassDataType,
                                         keyspace:
                                             *const ::std::os::raw::c_char,
                                         keyspace_length: size_t)
     -> CassError;
    pub fn cass_data_type_class_name(data_type: *const CassDataType,
                                     class_name:
                                         *mut *const ::std::os::raw::c_char,
                                     class_name_length: *mut size_t)
     -> CassError;
    pub fn cass_data_type_set_class_name(data_type: *mut CassDataType,
                                         class_name:
                                             *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_data_type_set_class_name_n(data_type: *mut CassDataType,
                                           class_name:
                                               *const ::std::os::raw::c_char,
                                           class_name_length: size_t)
     -> CassError;
    pub fn cass_data_type_sub_type_count(data_type: *const CassDataType)
     -> size_t;
    pub fn cass_data_sub_type_count(data_type: *const CassDataType) -> size_t;
    pub fn cass_data_type_sub_data_type(data_type: *const CassDataType,
                                        index: size_t) -> *const CassDataType;
    pub fn cass_data_type_sub_data_type_by_name(data_type:
                                                    *const CassDataType,
                                                name:
                                                    *const ::std::os::raw::c_char)
     -> *const CassDataType;
    pub fn cass_data_type_sub_data_type_by_name_n(data_type:
                                                      *const CassDataType,
                                                  name:
                                                      *const ::std::os::raw::c_char,
                                                  name_length: size_t)
     -> *const CassDataType;
    pub fn cass_data_type_sub_type_name(data_type: *const CassDataType,
                                        index: size_t,
                                        name:
                                            *mut *const ::std::os::raw::c_char,
                                        name_length: *mut size_t)
     -> CassError;
    pub fn cass_data_type_add_sub_type(data_type: *mut CassDataType,
                                       sub_data_type: *const CassDataType)
     -> CassError;
    pub fn cass_data_type_add_sub_type_by_name(data_type: *mut CassDataType,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               sub_data_type:
                                                   *const CassDataType)
     -> CassError;
    pub fn cass_data_type_add_sub_type_by_name_n(data_type: *mut CassDataType,
                                                 name:
                                                     *const ::std::os::raw::c_char,
                                                 name_length: size_t,
                                                 sub_data_type:
                                                     *const CassDataType)
     -> CassError;
    pub fn cass_data_type_add_sub_value_type(data_type: *mut CassDataType,
                                             sub_value_type: CassValueType)
     -> CassError;
    pub fn cass_data_type_add_sub_value_type_by_name(data_type:
                                                         *mut CassDataType,
                                                     name:
                                                         *const ::std::os::raw::c_char,
                                                     sub_value_type:
                                                         CassValueType)
     -> CassError;
    pub fn cass_data_type_add_sub_value_type_by_name_n(data_type:
                                                           *mut CassDataType,
                                                       name:
                                                           *const ::std::os::raw::c_char,
                                                       name_length: size_t,
                                                       sub_value_type:
                                                           CassValueType)
     -> CassError;
    pub fn cass_collection_new(type_: CassCollectionType, item_count: size_t)
     -> *mut CassCollection;
    pub fn cass_collection_new_from_data_type(data_type: *const CassDataType,
                                              item_count: size_t)
     -> *mut CassCollection;
    pub fn cass_collection_free(collection: *mut CassCollection);
    pub fn cass_collection_data_type(collection: *const CassCollection)
     -> *const CassDataType;
    pub fn cass_collection_append_int8(collection: *mut CassCollection,
                                       value: cass_int8_t) -> CassError;
    pub fn cass_collection_append_int16(collection: *mut CassCollection,
                                        value: cass_int16_t) -> CassError;
    pub fn cass_collection_append_int32(collection: *mut CassCollection,
                                        value: cass_int32_t) -> CassError;
    pub fn cass_collection_append_uint32(collection: *mut CassCollection,
                                         value: cass_uint32_t) -> CassError;
    pub fn cass_collection_append_int64(collection: *mut CassCollection,
                                        value: cass_int64_t) -> CassError;
    pub fn cass_collection_append_float(collection: *mut CassCollection,
                                        value: cass_float_t) -> CassError;
    pub fn cass_collection_append_double(collection: *mut CassCollection,
                                         value: cass_double_t) -> CassError;
    pub fn cass_collection_append_bool(collection: *mut CassCollection,
                                       value: cass_bool_t) -> CassError;
    pub fn cass_collection_append_string(collection: *mut CassCollection,
                                         value: *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_collection_append_string_n(collection: *mut CassCollection,
                                           value:
                                               *const ::std::os::raw::c_char,
                                           value_length: size_t) -> CassError;
    pub fn cass_collection_append_bytes(collection: *mut CassCollection,
                                        value: *const cass_byte_t,
                                        value_size: size_t) -> CassError;
    pub fn cass_collection_append_custom(collection: *mut CassCollection,
                                         class_name:
                                             *const ::std::os::raw::c_char,
                                         value: *const cass_byte_t,
                                         value_size: size_t) -> CassError;
    pub fn cass_collection_append_custom_n(collection: *mut CassCollection,
                                           class_name:
                                               *const ::std::os::raw::c_char,
                                           class_name_length: size_t,
                                           value: *const cass_byte_t,
                                           value_size: size_t) -> CassError;
    pub fn cass_collection_append_uuid(collection: *mut CassCollection,
                                       value: CassUuid) -> CassError;
    pub fn cass_collection_append_inet(collection: *mut CassCollection,
                                       value: CassInet) -> CassError;
    pub fn cass_collection_append_decimal(collection: *mut CassCollection,
                                          varint: *const cass_byte_t,
                                          varint_size: size_t,
                                          scale: cass_int32_t) -> CassError;
    pub fn cass_collection_append_collection(collection: *mut CassCollection,
                                             value: *const CassCollection)
     -> CassError;
    pub fn cass_collection_append_tuple(collection: *mut CassCollection,
                                        value: *const CassTuple) -> CassError;
    pub fn cass_collection_append_user_type(collection: *mut CassCollection,
                                            value: *const CassUserType)
     -> CassError;
    pub fn cass_tuple_new(item_count: size_t) -> *mut CassTuple;
    pub fn cass_tuple_new_from_data_type(data_type: *const CassDataType)
     -> *mut CassTuple;
    pub fn cass_tuple_free(tuple: *mut CassTuple);
    pub fn cass_tuple_data_type(tuple: *const CassTuple)
     -> *const CassDataType;
    pub fn cass_tuple_set_null(tuple: *mut CassTuple, index: size_t)
     -> CassError;
    pub fn cass_tuple_set_int8(tuple: *mut CassTuple, index: size_t,
                               value: cass_int8_t) -> CassError;
    pub fn cass_tuple_set_int16(tuple: *mut CassTuple, index: size_t,
                                value: cass_int16_t) -> CassError;
    pub fn cass_tuple_set_int32(tuple: *mut CassTuple, index: size_t,
                                value: cass_int32_t) -> CassError;
    pub fn cass_tuple_set_uint32(tuple: *mut CassTuple, index: size_t,
                                 value: cass_uint32_t) -> CassError;
    pub fn cass_tuple_set_int64(tuple: *mut CassTuple, index: size_t,
                                value: cass_int64_t) -> CassError;
    pub fn cass_tuple_set_float(tuple: *mut CassTuple, index: size_t,
                                value: cass_float_t) -> CassError;
    pub fn cass_tuple_set_double(tuple: *mut CassTuple, index: size_t,
                                 value: cass_double_t) -> CassError;
    pub fn cass_tuple_set_bool(tuple: *mut CassTuple, index: size_t,
                               value: cass_bool_t) -> CassError;
    pub fn cass_tuple_set_string(tuple: *mut CassTuple, index: size_t,
                                 value: *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_tuple_set_string_n(tuple: *mut CassTuple, index: size_t,
                                   value: *const ::std::os::raw::c_char,
                                   value_length: size_t) -> CassError;
    pub fn cass_tuple_set_bytes(tuple: *mut CassTuple, index: size_t,
                                value: *const cass_byte_t, value_size: size_t)
     -> CassError;
    pub fn cass_tuple_set_custom(tuple: *mut CassTuple, index: size_t,
                                 class_name: *const ::std::os::raw::c_char,
                                 value: *const cass_byte_t,
                                 value_size: size_t) -> CassError;
    pub fn cass_tuple_set_custom_n(tuple: *mut CassTuple, index: size_t,
                                   class_name: *const ::std::os::raw::c_char,
                                   class_name_length: size_t,
                                   value: *const cass_byte_t,
                                   value_size: size_t) -> CassError;
    pub fn cass_tuple_set_uuid(tuple: *mut CassTuple, index: size_t,
                               value: CassUuid) -> CassError;
    pub fn cass_tuple_set_inet(tuple: *mut CassTuple, index: size_t,
                               value: CassInet) -> CassError;
    pub fn cass_tuple_set_decimal(tuple: *mut CassTuple, index: size_t,
                                  varint: *const cass_byte_t,
                                  varint_size: size_t, scale: cass_int32_t)
     -> CassError;
    pub fn cass_tuple_set_collection(tuple: *mut CassTuple, index: size_t,
                                     value: *const CassCollection)
     -> CassError;
    pub fn cass_tuple_set_tuple(tuple: *mut CassTuple, index: size_t,
                                value: *const CassTuple) -> CassError;
    pub fn cass_tuple_set_user_type(tuple: *mut CassTuple, index: size_t,
                                    value: *const CassUserType) -> CassError;
    pub fn cass_user_type_new_from_data_type(data_type: *const CassDataType)
     -> *mut CassUserType;
    pub fn cass_user_type_free(user_type: *mut CassUserType);
    pub fn cass_user_type_data_type(user_type: *const CassUserType)
     -> *const CassDataType;
    pub fn cass_user_type_set_null(user_type: *mut CassUserType,
                                   index: size_t) -> CassError;
    pub fn cass_user_type_set_null_by_name(user_type: *mut CassUserType,
                                           name:
                                               *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_user_type_set_null_by_name_n(user_type: *mut CassUserType,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             name_length: size_t)
     -> CassError;
    pub fn cass_user_type_set_int8(user_type: *mut CassUserType,
                                   index: size_t, value: cass_int8_t)
     -> CassError;
    pub fn cass_user_type_set_int8_by_name(user_type: *mut CassUserType,
                                           name:
                                               *const ::std::os::raw::c_char,
                                           value: cass_int8_t) -> CassError;
    pub fn cass_user_type_set_int8_by_name_n(user_type: *mut CassUserType,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             name_length: size_t,
                                             value: cass_int8_t) -> CassError;
    pub fn cass_user_type_set_int16(user_type: *mut CassUserType,
                                    index: size_t, value: cass_int16_t)
     -> CassError;
    pub fn cass_user_type_set_int16_by_name(user_type: *mut CassUserType,
                                            name:
                                                *const ::std::os::raw::c_char,
                                            value: cass_int16_t) -> CassError;
    pub fn cass_user_type_set_int16_by_name_n(user_type: *mut CassUserType,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t,
                                              value: cass_int16_t)
     -> CassError;
    pub fn cass_user_type_set_int32(user_type: *mut CassUserType,
                                    index: size_t, value: cass_int32_t)
     -> CassError;
    pub fn cass_user_type_set_int32_by_name(user_type: *mut CassUserType,
                                            name:
                                                *const ::std::os::raw::c_char,
                                            value: cass_int32_t) -> CassError;
    pub fn cass_user_type_set_int32_by_name_n(user_type: *mut CassUserType,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t,
                                              value: cass_int32_t)
     -> CassError;
    pub fn cass_user_type_set_uint32(user_type: *mut CassUserType,
                                     index: size_t, value: cass_uint32_t)
     -> CassError;
    pub fn cass_user_type_set_uint32_by_name(user_type: *mut CassUserType,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             value: cass_uint32_t)
     -> CassError;
    pub fn cass_user_type_set_uint32_by_name_n(user_type: *mut CassUserType,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               name_length: size_t,
                                               value: cass_uint32_t)
     -> CassError;
    pub fn cass_user_type_set_int64(user_type: *mut CassUserType,
                                    index: size_t, value: cass_int64_t)
     -> CassError;
    pub fn cass_user_type_set_int64_by_name(user_type: *mut CassUserType,
                                            name:
                                                *const ::std::os::raw::c_char,
                                            value: cass_int64_t) -> CassError;
    pub fn cass_user_type_set_int64_by_name_n(user_type: *mut CassUserType,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t,
                                              value: cass_int64_t)
     -> CassError;
    pub fn cass_user_type_set_float(user_type: *mut CassUserType,
                                    index: size_t, value: cass_float_t)
     -> CassError;
    pub fn cass_user_type_set_float_by_name(user_type: *mut CassUserType,
                                            name:
                                                *const ::std::os::raw::c_char,
                                            value: cass_float_t) -> CassError;
    pub fn cass_user_type_set_float_by_name_n(user_type: *mut CassUserType,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t,
                                              value: cass_float_t)
     -> CassError;
    pub fn cass_user_type_set_double(user_type: *mut CassUserType,
                                     index: size_t, value: cass_double_t)
     -> CassError;
    pub fn cass_user_type_set_double_by_name(user_type: *mut CassUserType,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             value: cass_double_t)
     -> CassError;
    pub fn cass_user_type_set_double_by_name_n(user_type: *mut CassUserType,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               name_length: size_t,
                                               value: cass_double_t)
     -> CassError;
    pub fn cass_user_type_set_bool(user_type: *mut CassUserType,
                                   index: size_t, value: cass_bool_t)
     -> CassError;
    pub fn cass_user_type_set_bool_by_name(user_type: *mut CassUserType,
                                           name:
                                               *const ::std::os::raw::c_char,
                                           value: cass_bool_t) -> CassError;
    pub fn cass_user_type_set_bool_by_name_n(user_type: *mut CassUserType,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             name_length: size_t,
                                             value: cass_bool_t) -> CassError;
    pub fn cass_user_type_set_string(user_type: *mut CassUserType,
                                     index: size_t,
                                     value: *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_user_type_set_string_n(user_type: *mut CassUserType,
                                       index: size_t,
                                       value: *const ::std::os::raw::c_char,
                                       value_length: size_t) -> CassError;
    pub fn cass_user_type_set_string_by_name(user_type: *mut CassUserType,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             value:
                                                 *const ::std::os::raw::c_char)
     -> CassError;
    pub fn cass_user_type_set_string_by_name_n(user_type: *mut CassUserType,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               name_length: size_t,
                                               value:
                                                   *const ::std::os::raw::c_char,
                                               value_length: size_t)
     -> CassError;
    pub fn cass_user_type_set_bytes(user_type: *mut CassUserType,
                                    index: size_t, value: *const cass_byte_t,
                                    value_size: size_t) -> CassError;
    pub fn cass_user_type_set_bytes_by_name(user_type: *mut CassUserType,
                                            name:
                                                *const ::std::os::raw::c_char,
                                            value: *const cass_byte_t,
                                            value_size: size_t) -> CassError;
    pub fn cass_user_type_set_bytes_by_name_n(user_type: *mut CassUserType,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t,
                                              value: *const cass_byte_t,
                                              value_size: size_t)
     -> CassError;
    pub fn cass_user_type_set_custom(user_type: *mut CassUserType,
                                     index: size_t,
                                     class_name:
                                         *const ::std::os::raw::c_char,
                                     value: *const cass_byte_t,
                                     value_size: size_t) -> CassError;
    pub fn cass_user_type_set_custom_n(user_type: *mut CassUserType,
                                       index: size_t,
                                       class_name:
                                           *const ::std::os::raw::c_char,
                                       class_name_length: size_t,
                                       value: *const cass_byte_t,
                                       value_size: size_t) -> CassError;
    pub fn cass_user_type_set_custom_by_name(user_type: *mut CassUserType,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             class_name:
                                                 *const ::std::os::raw::c_char,
                                             value: *const cass_byte_t,
                                             value_size: size_t) -> CassError;
    pub fn cass_user_type_set_custom_by_name_n(user_type: *mut CassUserType,
                                               name:
                                                   *const ::std::os::raw::c_char,
                                               name_length: size_t,
                                               class_name:
                                                   *const ::std::os::raw::c_char,
                                               class_name_length: size_t,
                                               value: *const cass_byte_t,
                                               value_size: size_t)
     -> CassError;
    pub fn cass_user_type_set_uuid(user_type: *mut CassUserType,
                                   index: size_t, value: CassUuid)
     -> CassError;
    pub fn cass_user_type_set_uuid_by_name(user_type: *mut CassUserType,
                                           name:
                                               *const ::std::os::raw::c_char,
                                           value: CassUuid) -> CassError;
    pub fn cass_user_type_set_uuid_by_name_n(user_type: *mut CassUserType,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             name_length: size_t,
                                             value: CassUuid) -> CassError;
    pub fn cass_user_type_set_inet(user_type: *mut CassUserType,
                                   index: size_t, value: CassInet)
     -> CassError;
    pub fn cass_user_type_set_inet_by_name(user_type: *mut CassUserType,
                                           name:
                                               *const ::std::os::raw::c_char,
                                           value: CassInet) -> CassError;
    pub fn cass_user_type_set_inet_by_name_n(user_type: *mut CassUserType,
                                             name:
                                                 *const ::std::os::raw::c_char,
                                             name_length: size_t,
                                             value: CassInet) -> CassError;
    pub fn cass_user_type_set_decimal(user_type: *mut CassUserType,
                                      index: size_t,
                                      varint: *const cass_byte_t,
                                      varint_size: size_t,
                                      scale: ::std::os::raw::c_int)
     -> CassError;
    pub fn cass_user_type_set_decimal_by_name(user_type: *mut CassUserType,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              varint: *const cass_byte_t,
                                              varint_size: size_t,
                                              scale: ::std::os::raw::c_int)
     -> CassError;
    pub fn cass_user_type_set_decimal_by_name_n(user_type: *mut CassUserType,
                                                name:
                                                    *const ::std::os::raw::c_char,
                                                name_length: size_t,
                                                varint: *const cass_byte_t,
                                                varint_size: size_t,
                                                scale: ::std::os::raw::c_int)
     -> CassError;
    pub fn cass_user_type_set_collection(user_type: *mut CassUserType,
                                         index: size_t,
                                         value: *const CassCollection)
     -> CassError;
    pub fn cass_user_type_set_collection_by_name(user_type: *mut CassUserType,
                                                 name:
                                                     *const ::std::os::raw::c_char,
                                                 value: *const CassCollection)
     -> CassError;
    pub fn cass_user_type_set_collection_by_name_n(user_type:
                                                       *mut CassUserType,
                                                   name:
                                                       *const ::std::os::raw::c_char,
                                                   name_length: size_t,
                                                   value:
                                                       *const CassCollection)
     -> CassError;
    pub fn cass_user_type_set_tuple(user_type: *mut CassUserType,
                                    index: size_t, value: *const CassTuple)
     -> CassError;
    pub fn cass_user_type_set_tuple_by_name(user_type: *mut CassUserType,
                                            name:
                                                *const ::std::os::raw::c_char,
                                            value: *const CassTuple)
     -> CassError;
    pub fn cass_user_type_set_tuple_by_name_n(user_type: *mut CassUserType,
                                              name:
                                                  *const ::std::os::raw::c_char,
                                              name_length: size_t,
                                              value: *const CassTuple)
     -> CassError;
    pub fn cass_user_type_set_user_type(user_type: *mut CassUserType,
                                        index: size_t,
                                        value: *const CassUserType)
     -> CassError;
    pub fn cass_user_type_set_user_type_by_name(user_type: *mut CassUserType,
                                                name:
                                                    *const ::std::os::raw::c_char,
                                                value: *const CassUserType)
     -> CassError;
    pub fn cass_user_type_set_user_type_by_name_n(user_type:
                                                      *mut CassUserType,
                                                  name:
                                                      *const ::std::os::raw::c_char,
                                                  name_length: size_t,
                                                  value: *const CassUserType)
     -> CassError;
    pub fn cass_result_free(result: *const CassResult);
    pub fn cass_result_row_count(result: *const CassResult) -> size_t;
    pub fn cass_result_column_count(result: *const CassResult) -> size_t;
    pub fn cass_result_column_name(result: *const CassResult, index: size_t,
                                   name: *mut *const ::std::os::raw::c_char,
                                   name_length: *mut size_t) -> CassError;
    pub fn cass_result_column_type(result: *const CassResult, index: size_t)
     -> CassValueType;
    pub fn cass_result_column_data_type(result: *const CassResult,
                                        index: size_t) -> *const CassDataType;
    pub fn cass_result_first_row(result: *const CassResult) -> *const CassRow;
    pub fn cass_result_has_more_pages(result: *const CassResult)
     -> cass_bool_t;
    pub fn cass_result_paging_state_token(result: *const CassResult,
                                          paging_state:
                                              *mut *const ::std::os::raw::c_char,
                                          paging_state_size: *mut size_t)
     -> CassError;
    pub fn cass_error_result_free(error_result: *const CassErrorResult);
    pub fn cass_error_result_code(error_result: *const CassErrorResult)
     -> CassError;
    pub fn cass_error_result_consistency(error_result: *const CassErrorResult)
     -> CassConsistency;
    // Name corrected; see CPP-502
    pub fn cass_error_result_actual(error_result: *const CassErrorResult)
     -> cass_int32_t;
    // Name corrected; see CPP-502
    pub fn cass_error_result_required(error_result: *const CassErrorResult)
     -> cass_int32_t;
    pub fn cass_error_result_num_failures(error_result:
                                              *const CassErrorResult)
     -> cass_int32_t;
    pub fn cass_error_result_data_present(error_result:
                                              *const CassErrorResult)
     -> cass_bool_t;
    pub fn cass_error_result_write_type(error_result: *const CassErrorResult)
     -> CassWriteType;
    pub fn cass_error_result_keyspace(error_result: *const CassErrorResult,
                                      keyspace:
                                          *mut *const ::std::os::raw::c_char,
                                      keyspace_length: *mut size_t)
     -> CassError;
    pub fn cass_error_result_table(error_result: *const CassErrorResult,
                                   table: *mut *const ::std::os::raw::c_char,
                                   table_length: *mut size_t) -> CassError;
    pub fn cass_error_result_function(error_result: *const CassErrorResult,
                                      function:
                                          *mut *const ::std::os::raw::c_char,
                                      function_length: *mut size_t)
     -> CassError;
    pub fn cass_error_num_arg_types(error_result: *const CassErrorResult)
     -> size_t;
    pub fn cass_error_result_arg_type(error_result: *const CassErrorResult,
                                      index: size_t,
                                      arg_type:
                                          *mut *const ::std::os::raw::c_char,
                                      arg_type_length: *mut size_t)
     -> CassError;
    pub fn cass_iterator_free(iterator: *mut CassIterator);
    pub fn cass_iterator_type(iterator: *mut CassIterator)
     -> CassIteratorType;
    pub fn cass_iterator_from_result(result: *const CassResult)
     -> *mut CassIterator;
    pub fn cass_iterator_from_row(row: *const CassRow) -> *mut CassIterator;
    pub fn cass_iterator_from_collection(value: *const CassValue)
     -> *mut CassIterator;
    pub fn cass_iterator_from_map(value: *const CassValue)
     -> *mut CassIterator;
    pub fn cass_iterator_from_tuple(value: *const CassValue)
     -> *mut CassIterator;
    pub fn cass_iterator_fields_from_user_type(value: *const CassValue)
     -> *mut CassIterator;
    pub fn cass_iterator_keyspaces_from_schema_meta(schema_meta:
                                                        *const CassSchemaMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_tables_from_keyspace_meta(keyspace_meta:
                                                       *const CassKeyspaceMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_materialized_views_from_keyspace_meta(keyspace_meta:
                                                                   *const CassKeyspaceMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_user_types_from_keyspace_meta(keyspace_meta:
                                                           *const CassKeyspaceMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_functions_from_keyspace_meta(keyspace_meta:
                                                          *const CassKeyspaceMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_aggregates_from_keyspace_meta(keyspace_meta:
                                                           *const CassKeyspaceMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_fields_from_keyspace_meta(keyspace_meta:
                                                       *const CassKeyspaceMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_columns_from_table_meta(table_meta:
                                                     *const CassTableMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_indexes_from_table_meta(table_meta:
                                                     *const CassTableMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_materialized_views_from_table_meta(table_meta:
                                                                *const CassTableMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_fields_from_table_meta(table_meta:
                                                    *const CassTableMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_columns_from_materialized_view_meta(view_meta:
                                                                 *const CassMaterializedViewMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_fields_from_materialized_view_meta(view_meta:
                                                                *const CassMaterializedViewMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_fields_from_column_meta(column_meta:
                                                     *const CassColumnMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_fields_from_index_meta(index_meta:
                                                    *const CassIndexMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_fields_from_function_meta(function_meta:
                                                       *const CassFunctionMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_fields_from_aggregate_meta(aggregate_meta:
                                                        *const CassAggregateMeta)
     -> *mut CassIterator;
    pub fn cass_iterator_next(iterator: *mut CassIterator) -> cass_bool_t;
    pub fn cass_iterator_get_row(iterator: *const CassIterator)
     -> *const CassRow;
    pub fn cass_iterator_get_column(iterator: *const CassIterator)
     -> *const CassValue;
    pub fn cass_iterator_get_value(iterator: *const CassIterator)
     -> *const CassValue;
    pub fn cass_iterator_get_map_key(iterator: *const CassIterator)
     -> *const CassValue;
    pub fn cass_iterator_get_map_value(iterator: *const CassIterator)
     -> *const CassValue;
    pub fn cass_iterator_get_user_type_field_name(iterator:
                                                      *const CassIterator,
                                                  name:
                                                      *mut *const ::std::os::raw::c_char,
                                                  name_length: *mut size_t)
     -> CassError;
    pub fn cass_iterator_get_user_type_field_value(iterator:
                                                       *const CassIterator)
     -> *const CassValue;
    pub fn cass_iterator_get_keyspace_meta(iterator: *const CassIterator)
     -> *const CassKeyspaceMeta;
    pub fn cass_iterator_get_table_meta(iterator: *const CassIterator)
     -> *const CassTableMeta;
    pub fn cass_iterator_get_materialized_view_meta(iterator:
                                                        *const CassIterator)
     -> *const CassMaterializedViewMeta;
    pub fn cass_iterator_get_user_type(iterator: *const CassIterator)
     -> *const CassDataType;
    pub fn cass_iterator_get_function_meta(iterator: *const CassIterator)
     -> *const CassFunctionMeta;
    pub fn cass_iterator_get_aggregate_meta(iterator: *const CassIterator)
     -> *const CassAggregateMeta;
    pub fn cass_iterator_get_column_meta(iterator: *const CassIterator)
     -> *const CassColumnMeta;
    pub fn cass_iterator_get_index_meta(iterator: *const CassIterator)
     -> *const CassIndexMeta;
    pub fn cass_iterator_get_meta_field_name(iterator: *const CassIterator,
                                             name:
                                                 *mut *const ::std::os::raw::c_char,
                                             name_length: *mut size_t)
     -> CassError;
    pub fn cass_iterator_get_meta_field_value(iterator: *const CassIterator)
     -> *const CassValue;
    pub fn cass_row_get_column(row: *const CassRow, index: size_t)
     -> *const CassValue;
    pub fn cass_row_get_column_by_name(row: *const CassRow,
                                       name: *const ::std::os::raw::c_char)
     -> *const CassValue;
    pub fn cass_row_get_column_by_name_n(row: *const CassRow,
                                         name: *const ::std::os::raw::c_char,
                                         name_length: size_t)
     -> *const CassValue;
    pub fn cass_value_data_type(value: *const CassValue)
     -> *const CassDataType;
    pub fn cass_value_get_int8(value: *const CassValue,
                               output: *mut cass_int8_t) -> CassError;
    pub fn cass_value_get_int16(value: *const CassValue,
                                output: *mut cass_int16_t) -> CassError;
    pub fn cass_value_get_int32(value: *const CassValue,
                                output: *mut cass_int32_t) -> CassError;
    pub fn cass_value_get_uint32(value: *const CassValue,
                                 output: *mut cass_uint32_t) -> CassError;
    pub fn cass_value_get_int64(value: *const CassValue,
                                output: *mut cass_int64_t) -> CassError;
    pub fn cass_value_get_float(value: *const CassValue,
                                output: *mut cass_float_t) -> CassError;
    pub fn cass_value_get_double(value: *const CassValue,
                                 output: *mut cass_double_t) -> CassError;
    pub fn cass_value_get_bool(value: *const CassValue,
                               output: *mut cass_bool_t) -> CassError;
    pub fn cass_value_get_uuid(value: *const CassValue, output: *mut CassUuid)
     -> CassError;
    pub fn cass_value_get_inet(value: *const CassValue, output: *mut CassInet)
     -> CassError;
    pub fn cass_value_get_string(value: *const CassValue,
                                 output: *mut *const ::std::os::raw::c_char,
                                 output_size: *mut size_t) -> CassError;
    pub fn cass_value_get_bytes(value: *const CassValue,
                                output: *mut *const cass_byte_t,
                                output_size: *mut size_t) -> CassError;
    pub fn cass_value_get_decimal(value: *const CassValue,
                                  varint: *mut *const cass_byte_t,
                                  varint_size: *mut size_t,
                                  scale: *mut cass_int32_t) -> CassError;
    pub fn cass_value_type(value: *const CassValue) -> CassValueType;
    pub fn cass_value_is_null(value: *const CassValue) -> cass_bool_t;
    pub fn cass_value_is_collection(value: *const CassValue) -> cass_bool_t;
    pub fn cass_value_item_count(collection: *const CassValue) -> size_t;
    pub fn cass_value_primary_sub_type(collection: *const CassValue)
     -> CassValueType;
    pub fn cass_value_secondary_sub_type(collection: *const CassValue)
     -> CassValueType;
    pub fn cass_uuid_gen_new() -> *mut CassUuidGen;
    pub fn cass_uuid_gen_new_with_node(node: cass_uint64_t)
     -> *mut CassUuidGen;
    pub fn cass_uuid_gen_free(uuid_gen: *mut CassUuidGen);
    pub fn cass_uuid_gen_time(uuid_gen: *mut CassUuidGen,
                              output: *mut CassUuid);
    pub fn cass_uuid_gen_random(uuid_gen: *mut CassUuidGen,
                                output: *mut CassUuid);
    pub fn cass_uuid_gen_from_time(uuid_gen: *mut CassUuidGen,
                                   timestamp: cass_uint64_t,
                                   output: *mut CassUuid);
    pub fn cass_uuid_min_from_time(time: cass_uint64_t,
                                   output: *mut CassUuid);
    pub fn cass_uuid_max_from_time(time: cass_uint64_t,
                                   output: *mut CassUuid);
    pub fn cass_uuid_timestamp(uuid: CassUuid) -> cass_uint64_t;
    pub fn cass_uuid_version(uuid: CassUuid) -> cass_uint8_t;
    pub fn cass_uuid_string(uuid: CassUuid,
                            output: *mut ::std::os::raw::c_char);
    pub fn cass_uuid_from_string(str: *const ::std::os::raw::c_char,
                                 output: *mut CassUuid) -> CassError;
    pub fn cass_uuid_from_string_n(str: *const ::std::os::raw::c_char,
                                   str_length: size_t, output: *mut CassUuid)
     -> CassError;
    pub fn cass_timestamp_gen_server_side_new() -> *mut CassTimestampGen;
    pub fn cass_timestamp_gen_monotonic_new() -> *mut CassTimestampGen;
    pub fn cass_timestamp_gen_free(timestamp_gen: *mut CassTimestampGen);
    pub fn cass_retry_policy_default_new() -> *mut CassRetryPolicy;
    pub fn cass_retry_policy_downgrading_consistency_new()
     -> *mut CassRetryPolicy;
    pub fn cass_retry_policy_fallthrough_new() -> *mut CassRetryPolicy;
    pub fn cass_retry_policy_logging_new(child_retry_policy:
                                             *mut CassRetryPolicy)
     -> *mut CassRetryPolicy;
    pub fn cass_retry_policy_free(policy: *mut CassRetryPolicy);
    pub fn cass_custom_payload_new() -> *mut CassCustomPayload;
    pub fn cass_custom_payload_free(payload: *mut CassCustomPayload);
    pub fn cass_custom_payload_set(payload: *mut CassCustomPayload,
                                   name: *const ::std::os::raw::c_char,
                                   value: *const cass_byte_t,
                                   value_size: size_t);
    pub fn cass_custom_payload_set_n(payload: *mut CassCustomPayload,
                                     name: *const ::std::os::raw::c_char,
                                     name_length: size_t,
                                     value: *const cass_byte_t,
                                     value_size: size_t);
    pub fn cass_custom_payload_remove(payload: *mut CassCustomPayload,
                                      name: *const ::std::os::raw::c_char);
    pub fn cass_custom_payload_remove_n(payload: *mut CassCustomPayload,
                                        name: *const ::std::os::raw::c_char,
                                        name_length: size_t);
    pub fn cass_consistency_string(consistency: CassConsistency)
     -> *const ::std::os::raw::c_char;
    pub fn cass_write_type_string(write_type: CassWriteType)
     -> *const ::std::os::raw::c_char;
    pub fn cass_error_desc(error: CassError) -> *const ::std::os::raw::c_char;
    pub fn cass_log_cleanup();
    pub fn cass_log_set_level(log_level: CassLogLevel);
    pub fn cass_log_set_callback(callback: CassLogCallback,
                                 data: *mut ::std::os::raw::c_void);
    pub fn cass_log_set_queue_size(queue_size: size_t);
    pub fn cass_log_level_string(log_level: CassLogLevel)
     -> *const ::std::os::raw::c_char;
    pub fn cass_inet_init_v4(address: *const cass_uint8_t) -> CassInet;
    pub fn cass_inet_init_v6(address: *const cass_uint8_t) -> CassInet;
    pub fn cass_inet_string(inet: CassInet,
                            output: *mut ::std::os::raw::c_char);
    pub fn cass_inet_from_string(str: *const ::std::os::raw::c_char,
                                 output: *mut CassInet) -> CassError;
    pub fn cass_inet_from_string_n(str: *const ::std::os::raw::c_char,
                                   str_length: size_t, output: *mut CassInet)
     -> CassError;
    pub fn cass_date_from_epoch(epoch_secs: cass_int64_t) -> cass_uint32_t;
    pub fn cass_time_from_epoch(epoch_secs: cass_int64_t) -> cass_int64_t;
    pub fn cass_date_time_to_epoch(date: cass_uint32_t, time: cass_int64_t)
     -> cass_int64_t;
}