Rework to use the new flat steam api

14 files changed, 402 insertions, 548 deletions

diff --git a/src/app.rs b/src/app.rs
index 9df5820..3127459 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -19,7 +19,7 @@ impl <Manager> Apps<Manager> {
     /// This does not mean the user owns the game.
     pub fn is_app_installed(&self, app_id: AppId) -> bool {
         unsafe {
-            sys::SteamAPI_ISteamApps_BIsAppInstalled(self.apps, sys::AppId_t(app_id.0)) != 0
+            sys::SteamAPI_ISteamApps_BIsAppInstalled(self.apps, app_id.0)
         }
     }
 
@@ -27,7 +27,7 @@ impl <Manager> Apps<Manager> {
     /// installed.
     pub fn is_dlc_installed(&self, app_id: AppId) -> bool {
         unsafe {
-            sys::SteamAPI_ISteamApps_BIsDlcInstalled(self.apps, sys::AppId_t(app_id.0)) != 0
+            sys::SteamAPI_ISteamApps_BIsDlcInstalled(self.apps, app_id.0)
         }
     }
 
@@ -38,21 +38,21 @@ impl <Manager> Apps<Manager> {
     /// yours (e.g. demo).
     pub fn is_subscribed_app(&self, app_id: AppId) -> bool {
         unsafe {
-            sys::SteamAPI_ISteamApps_BIsSubscribedApp(self.apps, sys::AppId_t(app_id.0)) != 0
+            sys::SteamAPI_ISteamApps_BIsSubscribedApp(self.apps, app_id.0)
         }
     }
 
     /// Returns whether the user is subscribed via a free weekend
     pub fn is_subscribed_from_free_weekend(&self) -> bool {
         unsafe {
-            sys::SteamAPI_ISteamApps_BIsSubscribedFromFreeWeekend(self.apps) != 0
+            sys::SteamAPI_ISteamApps_BIsSubscribedFromFreeWeekend(self.apps)
         }
     }
 
     /// Returns whether the user has a VAC ban on their account.
     pub fn is_vac_banned(&self) -> bool {
         unsafe {
-            sys::SteamAPI_ISteamApps_BIsVACBanned(self.apps) != 0
+            sys::SteamAPI_ISteamApps_BIsVACBanned(self.apps)
         }
     }
 
@@ -60,7 +60,7 @@ impl <Manager> Apps<Manager> {
     /// is for cyber cafes.
     pub fn is_cybercafe(&self) -> bool {
         unsafe {
-            sys::SteamAPI_ISteamApps_BIsCybercafe(self.apps) != 0
+            sys::SteamAPI_ISteamApps_BIsCybercafe(self.apps)
         }
     }
 
@@ -68,14 +68,14 @@ impl <Manager> Apps<Manager> {
     /// provides low violence depots.
     pub fn is_low_violence(&self) -> bool {
         unsafe {
-            sys::SteamAPI_ISteamApps_BIsLowViolence(self.apps) != 0
+            sys::SteamAPI_ISteamApps_BIsLowViolence(self.apps)
         }
     }
 
     /// Returns whether the user is subscribed to the current app ID
     pub fn is_subscribed(&self) -> bool {
         unsafe {
-            sys::SteamAPI_ISteamApps_BIsSubscribed(self.apps) != 0
+            sys::SteamAPI_ISteamApps_BIsSubscribed(self.apps)
         }
     }
 
@@ -92,8 +92,8 @@ impl <Manager> Apps<Manager> {
     /// would be installed in the default location.
     pub fn app_install_dir(&self, app_id: AppId) -> String {
         unsafe {
-            let buffer = vec![0; 2048];
-            sys::SteamAPI_ISteamApps_GetAppInstallDir(self.apps, sys::AppId_t(app_id.0), buffer.as_ptr(), buffer.len() as u32);
+            let mut buffer = vec![0; 2048];
+            sys::SteamAPI_ISteamApps_GetAppInstallDir(self.apps, app_id.0, buffer.as_mut_ptr(), buffer.len() as u32);
             let path = CStr::from_ptr(buffer.as_ptr());
             path.to_string_lossy().into_owned()
         }
@@ -104,7 +104,7 @@ impl <Manager> Apps<Manager> {
     /// Differs from the current user if the app is borrowed.
     pub fn app_owner(&self) -> SteamId {
         unsafe {
-            SteamId(sys::SteamAPI_ISteamApps_GetAppOwner(self.apps).0)
+            SteamId(sys::SteamAPI_ISteamApps_GetAppOwner(self.apps))
         }
     }
 
@@ -138,8 +138,8 @@ impl <Manager> Apps<Manager> {
     /// returns `None`
     pub fn current_beta_name(&self) -> Option<String> {
         unsafe {
-            let buffer = vec![0; 256];
-            if sys::SteamAPI_ISteamApps_GetCurrentBetaName(self.apps, buffer.as_ptr(), buffer.len() as _) != 0 {
+            let mut buffer = vec![0; 256];
+            if sys::SteamAPI_ISteamApps_GetCurrentBetaName(self.apps, buffer.as_mut_ptr(), buffer.len() as _) {
                 let path = CStr::from_ptr(buffer.as_ptr());
                 Some(path.to_string_lossy().into_owned())
             } else {
diff --git a/src/callback.rs b/src/callback.rs
index f88946b..caa1a4b 100644
--- a/src/callback.rs
+++ b/src/callback.rs
@@ -3,11 +3,7 @@ use super::*;
 use libc::{ c_void };
 use crate::sys;
 
-use std::mem;
 use std::sync::{ Arc, Weak };
-use std::panic::*;
-use std::any::Any;
-use std::process::abort;
 
 pub unsafe trait Callback {
     const ID: i32;
@@ -20,7 +16,7 @@ pub unsafe trait Callback {
 ///
 /// Removes the callback when dropped
 pub struct CallbackHandle<Manager = ClientManager> {
-    handle: *mut c_void,
+    id: i32,
     inner: Weak<Inner<Manager>>,
 }
 unsafe impl <Manager> Send for CallbackHandle<Manager> {}
@@ -29,169 +25,33 @@ impl <Manager> Drop for CallbackHandle<Manager> {
     fn drop(&mut self) {
         if let Some(inner) = self.inner.upgrade() {
             let mut cb = inner.callbacks.lock().unwrap();
-            if let Some(pos) = cb.callbacks.iter().position(|v| *v == self.handle) {
-                cb.callbacks.swap_remove(pos);
-                unsafe { sys::delete_rust_callback(self.handle); }
-            }
+            cb.callbacks.remove(&self.id);
         }
     }
 }
 
-fn print_err(err: Box<dyn Any>) {
-    if let Some(err) = err.downcast_ref::<&str>() {
-        println!("Steam callback panicked: {}", err);
-    } else if let Some(err) = err.downcast_ref::<String>() {
-        println!("Steam callback panicked: {}", err);
-    } else {
-        println!("Steam callback panicked");
-    }
-}
-
-pub(crate) unsafe fn register_callback<C, F, Manager>(inner: &Arc<Inner<Manager>>, f: F, game_server: bool) -> CallbackHandle<Manager>
+pub(crate) unsafe fn register_callback<C, F, Manager>(inner: &Arc<Inner<Manager>>, mut f: F, _game_server: bool) -> CallbackHandle<Manager>
     where C: Callback,
           F: FnMut(C) + Send + 'static
 {
-    unsafe extern "C" fn run<C, F>(_: *mut c_void, userdata: *mut c_void, param: *mut c_void)
-            where C: Callback,
-                  F: FnMut(C) + Send + 'static
     {
-        let func: &mut F = &mut *(userdata as *mut F);
-        let param = C::from_raw(param);
-        let res = catch_unwind(AssertUnwindSafe(||
-            func(param)
-        ));
-        if let Err(err) = res {
-            print_err(err);
-            abort();
-        }
-    }
-
-    unsafe extern "C" fn run_extra<C, F>(cb: *mut c_void, userdata: *mut c_void, param: *mut c_void, _: u8, _: sys::SteamAPICall_t)
-        where C: Callback,
-              F: FnMut(C) + Send + 'static
-    {
-        run::<C, F>(cb, userdata, param);
-    }
-
-    unsafe extern "C" fn dealloc<C, F>(cb: *mut c_void, userdata: *mut c_void)
-        where C: Callback,
-              F: FnMut(C) + Send + 'static
-    {
-        sys::SteamAPI_UnregisterCallback(cb);
-
-        let func: Box<F> = Box::from_raw(userdata as _);
-
-        let res = catch_unwind(AssertUnwindSafe(move ||
-            // It's possible for callback to panic whilst being dropped
-            drop(func)
-        ));
-        if let Err(err) = res {
-            print_err(err);
-            abort();
-        }
+        let mut callbacks = inner.callbacks.lock().unwrap();
+        callbacks.callbacks.insert(C::ID, Box::new(move |param| {
+            let param = C::from_raw(param);
+            f(param)
+        }));
     }
-
-    let data = sys::CallbackData {
-        param_size: C::SIZE as _,
-        userdata: Box::into_raw(Box::new(f)) as _,
-        run: run::<C, F> as _,
-        run_extra: run_extra::<C, F> as _,
-        dealloc: dealloc::<C, F> as _,
-    };
-
-    let flags = if game_server { 0x02 } else { 0x00 };
-    let ptr = sys::create_rust_callback(flags, C::ID as _, data);
-
-    sys::SteamAPI_RegisterCallback(ptr, C::ID as _);
-
-    let mut cbs = inner.callbacks.lock().unwrap();
-    cbs.callbacks.push(ptr);
-
     CallbackHandle {
-        handle: ptr,
-        inner: Arc::downgrade(inner),
+        id: C::ID,
+        inner: Arc::downgrade(&inner),
     }
 }
 
-pub(crate) unsafe fn register_call_result<C, F, Manager>(inner: &Arc<Inner<Manager>>, api_call: sys::SteamAPICall_t, callback_id: i32, f: F)
+pub(crate) unsafe fn register_call_result<C, F, Manager>(inner: &Arc<Inner<Manager>>, api_call: sys::SteamAPICall_t, _callback_id: i32, mut f: F)
     where F: for <'a> FnMut(&'a C, bool) + 'static + Send
 {
-    struct CallData<F, Manager> {
-        func: F,
-        api_call: sys::SteamAPICall_t,
-        inner: Weak<Inner<Manager>>,
-    }
-
-    unsafe extern "C" fn run<C, F, Manager>(cb: *mut c_void, userdata: *mut c_void, param: *mut c_void)
-        where F: for<'a> FnMut(&'a C, bool) + Send + 'static
-    {
-        let data: &mut CallData<F, Manager> = &mut *(userdata as *mut CallData<F, Manager>);
-        let res = catch_unwind(AssertUnwindSafe(||
-            (data.func)(&*(param as *const _), false)
-        ));
-        if let Err(err) = res {
-            print_err(err);
-            abort();
-        }
-
-        sys::delete_rust_callback(cb);
-    }
-
-    unsafe extern "C" fn run_extra<C, F, Manager>(cb: *mut c_void, userdata: *mut c_void, param: *mut c_void, io_error: u8, api_call: sys::SteamAPICall_t)
-        where F: for<'a> FnMut(&'a C, bool) + Send + 'static
-    {
-        let data: &mut CallData<F, Manager> = &mut *(userdata as *mut CallData<F, Manager>);
-
-        if api_call == data.api_call {
-            let res = catch_unwind(AssertUnwindSafe(||
-                (data.func)(&*(param as *const _), io_error != 0)
-            ));
-            if let Err(err) = res {
-                print_err(err);
-                abort();
-            }
-            sys::delete_rust_callback(cb);
-        }
-    }
-
-    unsafe extern "C" fn dealloc<C, F, Manager>(_cb: *mut c_void, userdata: *mut c_void)
-        where F: for <'a> FnMut(&'a C, bool) + Send + 'static
-    {
-        let data: Box<CallData<F, Manager>> = Box::from_raw(userdata as _);
-
-        if let Some(inner) = data.inner.upgrade() {
-            let mut cbs = inner.callbacks.lock().unwrap();
-            cbs.call_results.remove(&data.api_call);
-        }
-
-        let res = catch_unwind(AssertUnwindSafe(move ||
-            // Its possible for callback to panic whilst being dropped
-            drop(data)
-        ));
-        if let Err(err) = res {
-            print_err(err);
-            abort();
-        }
-    }
-
-    let userdata = CallData {
-        func: f,
-        api_call: api_call,
-        inner: Arc::downgrade(&inner),
-    };
-
-    let data = sys::CallbackData {
-        param_size: mem::size_of::<C>() as _,
-        userdata: Box::into_raw(Box::new(userdata)) as _,
-        run: run::<C, F, Manager>,
-        run_extra: run_extra::<C, F, Manager>,
-        dealloc: dealloc::<C, F, Manager>,
-    };
-
-    let ptr = sys::create_rust_callback(0x00, callback_id, data);
-
-    sys::SteamAPI_RegisterCallResult(ptr, api_call);
-
-    let mut cbs = inner.callbacks.lock().unwrap();
-    cbs.call_results.insert(api_call, ptr);
-}
+    let mut callbacks = inner.callbacks.lock().unwrap();
+    callbacks.call_results.insert(api_call, Box::new(move |param, failed| {
+        f(&*(param as *const C), failed)
+    }));
+}
\ No newline at end of file
diff --git a/src/error.rs b/src/error.rs
index 0f5fc39..ce79cde 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -386,115 +386,115 @@ pub enum SteamError {
 impl From<sys::EResult> for SteamError {
     fn from(r: sys::EResult) -> Self {
         match r {
-            sys::EResult::EResultOK => panic!("EResult::EResultOK isn't an error"),
-            sys::EResult::EResultFail => SteamError::Generic,
-            sys::EResult::EResultNoConnection => SteamError::NoConnection,
-            sys::EResult::EResultInvalidPassword => SteamError::InvalidPassword,
-            sys::EResult::EResultLoggedInElsewhere => SteamError::LoggedInElsewhere,
-            sys::EResult::EResultInvalidProtocolVer => SteamError::InvalidProtocolVersion,
-            sys::EResult::EResultInvalidParam => SteamError::InvalidParameter,
-            sys::EResult::EResultFileNotFound => SteamError::FileNotFound,
-            sys::EResult::EResultBusy => SteamError::Busy,
-            sys::EResult::EResultInvalidState => SteamError::InvalidState,
-            sys::EResult::EResultInvalidName => SteamError::InvalidName,
-            sys::EResult::EResultInvalidEmail => SteamError::InvalidEmail,
-            sys::EResult::EResultDuplicateName => SteamError::DuplicateName,
-            sys::EResult::EResultAccessDenied => SteamError::AccessDenied,
-            sys::EResult::EResultTimeout => SteamError::Timeout,
-            sys::EResult::EResultBanned => SteamError::Banned,
-            sys::EResult::EResultAccountNotFound => SteamError::AccountNotFound,
-            sys::EResult::EResultInvalidSteamID => SteamError::InvalidSteamID,
-            sys::EResult::EResultServiceUnavailable => SteamError::ServiceUnavailable,
-            sys::EResult::EResultNotLoggedOn => SteamError::NotLoggedOn,
-            sys::EResult::EResultPending => SteamError::Pending,
-            sys::EResult::EResultEncryptionFailure => SteamError::EncryptionFailure,
-            sys::EResult::EResultInsufficientPrivilege => SteamError::InsufficientPrivilege,
-            sys::EResult::EResultLimitExceeded => SteamError::LimitExceeded,
-            sys::EResult::EResultRevoked => SteamError::Revoked,
-            sys::EResult::EResultExpired => SteamError::Expired,
-            sys::EResult::EResultAlreadyRedeemed => SteamError::AlreadyRedeemed,
-            sys::EResult::EResultDuplicateRequest => SteamError::DuplicateRequest,
-            sys::EResult::EResultAlreadyOwned => SteamError::AlreadyOwned,
-            sys::EResult::EResultIPNotFound => SteamError::IPNotFound,
-            sys::EResult::EResultPersistFailed => SteamError::PersistFailed,
-            sys::EResult::EResultLockingFailed => SteamError::LockingFailed,
-            sys::EResult::EResultLogonSessionReplaced => SteamError::LogonSessionReplaced,
-            sys::EResult::EResultConnectFailed => SteamError::ConnectFailed,
-            sys::EResult::EResultHandshakeFailed => SteamError::HandshakeFailed,
-            sys::EResult::EResultIOFailure => SteamError::IOFailure,
-            sys::EResult::EResultRemoteDisconnect => SteamError::RemoteDisconnect,
-            sys::EResult::EResultShoppingCartNotFound => SteamError::ShoppingCartNotFound,
-            sys::EResult::EResultBlocked => SteamError::Blocked,
-            sys::EResult::EResultIgnored => SteamError::Ignored,
-            sys::EResult::EResultNoMatch => SteamError::NoMatch,
-            sys::EResult::EResultAccountDisabled => SteamError::AccountDisabled,
-            sys::EResult::EResultServiceReadOnly => SteamError::ServiceReadOnly,
-            sys::EResult::EResultAccountNotFeatured => SteamError::AccountNotFeatured,
-            sys::EResult::EResultAdministratorOK => SteamError::AdministratorOK,
-            sys::EResult::EResultContentVersion => SteamError::ContentVersion,
-            sys::EResult::EResultTryAnotherCM => SteamError::TryAnotherCM,
-            sys::EResult::EResultPasswordRequiredToKickSession => SteamError::PasswordRequiredToKickSession,
-            sys::EResult::EResultAlreadyLoggedInElsewhere => SteamError::AlreadyLoggedInElsewhere,
-            sys::EResult::EResultSuspended => SteamError::Suspended,
-            sys::EResult::EResultCancelled => SteamError::Cancelled,
-            sys::EResult::EResultDataCorruption => SteamError::DataCorruption,
-            sys::EResult::EResultDiskFull => SteamError::DiskFull,
-            sys::EResult::EResultRemoteCallFailed => SteamError::RemoteCallFailed,
-            sys::EResult::EResultPasswordUnset => SteamError::PasswordUnset,
-            sys::EResult::EResultExternalAccountUnlinked => SteamError::ExternalAccountUnlinked,
-            sys::EResult::EResultPSNTicketInvalid => SteamError::PSNTicketInvalid,
-            sys::EResult::EResultExternalAccountAlreadyLinked => SteamError::ExternalAccountAlreadyLinked,
-            sys::EResult::EResultRemoteFileConflict => SteamError::RemoteFileConflict,
-            sys::EResult::EResultIllegalPassword => SteamError::IllegalPassword,
-            sys::EResult::EResultSameAsPreviousValue => SteamError::SameAsPreviousValue,
-            sys::EResult::EResultAccountLogonDenied => SteamError::AccountLogonDenied,
-            sys::EResult::EResultCannotUseOldPassword => SteamError::CannotUseOldPassword,
-            sys::EResult::EResultInvalidLoginAuthCode => SteamError::InvalidLoginAuthCode,
-            sys::EResult::EResultAccountLogonDeniedNoMail => SteamError::AccountLogonDeniedNoMail,
-            sys::EResult::EResultHardwareNotCapableOfIPT => SteamError::HardwareNotCapableOfIPT,
-            sys::EResult::EResultIPTInitError => SteamError::IPTInitError,
-            sys::EResult::EResultParentalControlRestricted => SteamError::ParentalControlRestricted,
-            sys::EResult::EResultFacebookQueryError => SteamError::FacebookQueryError,
-            sys::EResult::EResultExpiredLoginAuthCode => SteamError::ExpiredLoginAuthCode,
-            sys::EResult::EResultIPLoginRestrictionFailed => SteamError::IPLoginRestrictionFailed,
-            sys::EResult::EResultAccountLockedDown => SteamError::AccountLockedDown,
-            sys::EResult::EResultAccountLogonDeniedVerifiedEmailRequired => SteamError::AccountLogonDeniedVerifiedEmailRequired,
-            sys::EResult::EResultNoMatchingURL => SteamError::NoMatchingURL,
-            sys::EResult::EResultBadResponse => SteamError::BadResponse,
-            sys::EResult::EResultRequirePasswordReEntry => SteamError::RequirePasswordReEntry,
-            sys::EResult::EResultValueOutOfRange => SteamError::ValueOutOfRange,
-            sys::EResult::EResultUnexpectedError => SteamError::UnexpectedError,
-            sys::EResult::EResultDisabled => SteamError::Disabled,
-            sys::EResult::EResultInvalidCEGSubmission => SteamError::InvalidCEGSubmission,
-            sys::EResult::EResultRestrictedDevice => SteamError::RestrictedDevice,
-            sys::EResult::EResultRegionLocked => SteamError::RegionLocked,
-            sys::EResult::EResultRateLimitExceeded => SteamError::RateLimitExceeded,
-            sys::EResult::EResultAccountLoginDeniedNeedTwoFactor => SteamError::AccountLoginDeniedNeedTwoFactor,
-            sys::EResult::EResultItemDeleted => SteamError::ItemDeleted,
-            sys::EResult::EResultAccountLoginDeniedThrottle => SteamError::AccountLoginDeniedThrottle,
-            sys::EResult::EResultTwoFactorCodeMismatch => SteamError::TwoFactorCodeMismatch,
-            sys::EResult::EResultTwoFactorActivationCodeMismatch => SteamError::TwoFactorActivationCodeMismatch,
-            sys::EResult::EResultAccountAssociatedToMultiplePartners => SteamError::AccountAssociatedToMultiplePartners,
-            sys::EResult::EResultNotModified => SteamError::NotModified,
-            sys::EResult::EResultNoMobileDevice => SteamError::NoMobileDevice,
-            sys::EResult::EResultTimeNotSynced => SteamError::TimeNotSynced,
-            sys::EResult::EResultSmsCodeFailed => SteamError::SmsCodeFailed,
-            sys::EResult::EResultAccountLimitExceeded => SteamError::AccountLimitExceeded,
-            sys::EResult::EResultAccountActivityLimitExceeded => SteamError::AccountActivityLimitExceeded,
-            sys::EResult::EResultPhoneActivityLimitExceeded => SteamError::PhoneActivityLimitExceeded,
-            sys::EResult::EResultRefundToWallet => SteamError::RefundToWallet,
-            sys::EResult::EResultEmailSendFailure => SteamError::EmailSendFailure,
-            sys::EResult::EResultNotSettled => SteamError::NotSettled,
-            sys::EResult::EResultNeedCaptcha => SteamError::NeedCaptcha,
-            sys::EResult::EResultGSLTDenied => SteamError::GSLTDenied,
-            sys::EResult::EResultGSOwnerDenied => SteamError::GSOwnerDenied,
-            sys::EResult::EResultInvalidItemType => SteamError::InvalidItemType,
-            sys::EResult::EResultIPBanned => SteamError::IPBanned,
-            sys::EResult::EResultGSLTExpired => SteamError::GSLTExpired,
-            sys::EResult::EResultInsufficientFunds => SteamError::InsufficientFunds,
-            sys::EResult::EResultTooManyPending => SteamError::TooManyPending,
-            sys::EResult::EResultNoSiteLicensesFound => SteamError::NoSiteLicensesFound,
-            sys::EResult::EResultWGNetworkSendExceeded => SteamError::WGNetworkSendExceeded,
+            sys::EResult::k_EResultOK => panic!("EResult::k_EResultOK isn't an error"),
+            sys::EResult::k_EResultFail => SteamError::Generic,
+            sys::EResult::k_EResultNoConnection => SteamError::NoConnection,
+            sys::EResult::k_EResultInvalidPassword => SteamError::InvalidPassword,
+            sys::EResult::k_EResultLoggedInElsewhere => SteamError::LoggedInElsewhere,
+            sys::EResult::k_EResultInvalidProtocolVer => SteamError::InvalidProtocolVersion,
+            sys::EResult::k_EResultInvalidParam => SteamError::InvalidParameter,
+            sys::EResult::k_EResultFileNotFound => SteamError::FileNotFound,
+            sys::EResult::k_EResultBusy => SteamError::Busy,
+            sys::EResult::k_EResultInvalidState => SteamError::InvalidState,
+            sys::EResult::k_EResultInvalidName => SteamError::InvalidName,
+            sys::EResult::k_EResultInvalidEmail => SteamError::InvalidEmail,
+            sys::EResult::k_EResultDuplicateName => SteamError::DuplicateName,
+            sys::EResult::k_EResultAccessDenied => SteamError::AccessDenied,
+            sys::EResult::k_EResultTimeout => SteamError::Timeout,
+            sys::EResult::k_EResultBanned => SteamError::Banned,
+            sys::EResult::k_EResultAccountNotFound => SteamError::AccountNotFound,
+            sys::EResult::k_EResultInvalidSteamID => SteamError::InvalidSteamID,
+            sys::EResult::k_EResultServiceUnavailable => SteamError::ServiceUnavailable,
+            sys::EResult::k_EResultNotLoggedOn => SteamError::NotLoggedOn,
+            sys::EResult::k_EResultPending => SteamError::Pending,
+            sys::EResult::k_EResultEncryptionFailure => SteamError::EncryptionFailure,
+            sys::EResult::k_EResultInsufficientPrivilege => SteamError::InsufficientPrivilege,
+            sys::EResult::k_EResultLimitExceeded => SteamError::LimitExceeded,
+            sys::EResult::k_EResultRevoked => SteamError::Revoked,
+            sys::EResult::k_EResultExpired => SteamError::Expired,
+            sys::EResult::k_EResultAlreadyRedeemed => SteamError::AlreadyRedeemed,
+            sys::EResult::k_EResultDuplicateRequest => SteamError::DuplicateRequest,
+            sys::EResult::k_EResultAlreadyOwned => SteamError::AlreadyOwned,
+            sys::EResult::k_EResultIPNotFound => SteamError::IPNotFound,
+            sys::EResult::k_EResultPersistFailed => SteamError::PersistFailed,
+            sys::EResult::k_EResultLockingFailed => SteamError::LockingFailed,
+            sys::EResult::k_EResultLogonSessionReplaced => SteamError::LogonSessionReplaced,
+            sys::EResult::k_EResultConnectFailed => SteamError::ConnectFailed,
+            sys::EResult::k_EResultHandshakeFailed => SteamError::HandshakeFailed,
+            sys::EResult::k_EResultIOFailure => SteamError::IOFailure,
+            sys::EResult::k_EResultRemoteDisconnect => SteamError::RemoteDisconnect,
+            sys::EResult::k_EResultShoppingCartNotFound => SteamError::ShoppingCartNotFound,
+            sys::EResult::k_EResultBlocked => SteamError::Blocked,
+            sys::EResult::k_EResultIgnored => SteamError::Ignored,
+            sys::EResult::k_EResultNoMatch => SteamError::NoMatch,
+            sys::EResult::k_EResultAccountDisabled => SteamError::AccountDisabled,
+            sys::EResult::k_EResultServiceReadOnly => SteamError::ServiceReadOnly,
+            sys::EResult::k_EResultAccountNotFeatured => SteamError::AccountNotFeatured,
+            sys::EResult::k_EResultAdministratorOK => SteamError::AdministratorOK,
+            sys::EResult::k_EResultContentVersion => SteamError::ContentVersion,
+            sys::EResult::k_EResultTryAnotherCM => SteamError::TryAnotherCM,
+            sys::EResult::k_EResultPasswordRequiredToKickSession => SteamError::PasswordRequiredToKickSession,
+            sys::EResult::k_EResultAlreadyLoggedInElsewhere => SteamError::AlreadyLoggedInElsewhere,
+            sys::EResult::k_EResultSuspended => SteamError::Suspended,
+            sys::EResult::k_EResultCancelled => SteamError::Cancelled,
+            sys::EResult::k_EResultDataCorruption => SteamError::DataCorruption,
+            sys::EResult::k_EResultDiskFull => SteamError::DiskFull,
+            sys::EResult::k_EResultRemoteCallFailed => SteamError::RemoteCallFailed,
+            sys::EResult::k_EResultPasswordUnset => SteamError::PasswordUnset,
+            sys::EResult::k_EResultExternalAccountUnlinked => SteamError::ExternalAccountUnlinked,
+            sys::EResult::k_EResultPSNTicketInvalid => SteamError::PSNTicketInvalid,
+            sys::EResult::k_EResultExternalAccountAlreadyLinked => SteamError::ExternalAccountAlreadyLinked,
+            sys::EResult::k_EResultRemoteFileConflict => SteamError::RemoteFileConflict,
+            sys::EResult::k_EResultIllegalPassword => SteamError::IllegalPassword,
+            sys::EResult::k_EResultSameAsPreviousValue => SteamError::SameAsPreviousValue,
+            sys::EResult::k_EResultAccountLogonDenied => SteamError::AccountLogonDenied,
+            sys::EResult::k_EResultCannotUseOldPassword => SteamError::CannotUseOldPassword,
+            sys::EResult::k_EResultInvalidLoginAuthCode => SteamError::InvalidLoginAuthCode,
+            sys::EResult::k_EResultAccountLogonDeniedNoMail => SteamError::AccountLogonDeniedNoMail,
+            sys::EResult::k_EResultHardwareNotCapableOfIPT => SteamError::HardwareNotCapableOfIPT,
+            sys::EResult::k_EResultIPTInitError => SteamError::IPTInitError,
+            sys::EResult::k_EResultParentalControlRestricted => SteamError::ParentalControlRestricted,
+            sys::EResult::k_EResultFacebookQueryError => SteamError::FacebookQueryError,
+            sys::EResult::k_EResultExpiredLoginAuthCode => SteamError::ExpiredLoginAuthCode,
+            sys::EResult::k_EResultIPLoginRestrictionFailed => SteamError::IPLoginRestrictionFailed,
+            sys::EResult::k_EResultAccountLockedDown => SteamError::AccountLockedDown,
+            sys::EResult::k_EResultAccountLogonDeniedVerifiedEmailRequired => SteamError::AccountLogonDeniedVerifiedEmailRequired,
+            sys::EResult::k_EResultNoMatchingURL => SteamError::NoMatchingURL,
+            sys::EResult::k_EResultBadResponse => SteamError::BadResponse,
+            sys::EResult::k_EResultRequirePasswordReEntry => SteamError::RequirePasswordReEntry,
+            sys::EResult::k_EResultValueOutOfRange => SteamError::ValueOutOfRange,
+            sys::EResult::k_EResultUnexpectedError => SteamError::UnexpectedError,
+            sys::EResult::k_EResultDisabled => SteamError::Disabled,
+            sys::EResult::k_EResultInvalidCEGSubmission => SteamError::InvalidCEGSubmission,
+            sys::EResult::k_EResultRestrictedDevice => SteamError::RestrictedDevice,
+            sys::EResult::k_EResultRegionLocked => SteamError::RegionLocked,
+            sys::EResult::k_EResultRateLimitExceeded => SteamError::RateLimitExceeded,
+            sys::EResult::k_EResultAccountLoginDeniedNeedTwoFactor => SteamError::AccountLoginDeniedNeedTwoFactor,
+            sys::EResult::k_EResultItemDeleted => SteamError::ItemDeleted,
+            sys::EResult::k_EResultAccountLoginDeniedThrottle => SteamError::AccountLoginDeniedThrottle,
+            sys::EResult::k_EResultTwoFactorCodeMismatch => SteamError::TwoFactorCodeMismatch,
+            sys::EResult::k_EResultTwoFactorActivationCodeMismatch => SteamError::TwoFactorActivationCodeMismatch,
+            sys::EResult::k_EResultAccountAssociatedToMultiplePartners => SteamError::AccountAssociatedToMultiplePartners,
+            sys::EResult::k_EResultNotModified => SteamError::NotModified,
+            sys::EResult::k_EResultNoMobileDevice => SteamError::NoMobileDevice,
+            sys::EResult::k_EResultTimeNotSynced => SteamError::TimeNotSynced,
+            sys::EResult::k_EResultSmsCodeFailed => SteamError::SmsCodeFailed,
+            sys::EResult::k_EResultAccountLimitExceeded => SteamError::AccountLimitExceeded,
+            sys::EResult::k_EResultAccountActivityLimitExceeded => SteamError::AccountActivityLimitExceeded,
+            sys::EResult::k_EResultPhoneActivityLimitExceeded => SteamError::PhoneActivityLimitExceeded,
+            sys::EResult::k_EResultRefundToWallet => SteamError::RefundToWallet,
+            sys::EResult::k_EResultEmailSendFailure => SteamError::EmailSendFailure,
+            sys::EResult::k_EResultNotSettled => SteamError::NotSettled,
+            sys::EResult::k_EResultNeedCaptcha => SteamError::NeedCaptcha,
+            sys::EResult::k_EResultGSLTDenied => SteamError::GSLTDenied,
+            sys::EResult::k_EResultGSOwnerDenied => SteamError::GSOwnerDenied,
+            sys::EResult::k_EResultInvalidItemType => SteamError::InvalidItemType,
+            sys::EResult::k_EResultIPBanned => SteamError::IPBanned,
+            sys::EResult::k_EResultGSLTExpired => SteamError::GSLTExpired,
+            sys::EResult::k_EResultInsufficientFunds => SteamError::InsufficientFunds,
+            sys::EResult::k_EResultTooManyPending => SteamError::TooManyPending,
+            sys::EResult::k_EResultNoSiteLicensesFound => SteamError::NoSiteLicensesFound,
+            sys::EResult::k_EResultWGNetworkSendExceeded => SteamError::WGNetworkSendExceeded,
             _ => unreachable!(),
         }
     }
diff --git a/src/friends.rs b/src/friends.rs
index 82e4633..5159732 100644
--- a/src/friends.rs
+++ b/src/friends.rs
@@ -71,7 +71,7 @@ impl <Manager> Friends<Manager> {
             }
             let mut friends = Vec::with_capacity(count as usize);
             for idx in 0 .. count {
-                let friend = SteamId(sys::SteamAPI_ISteamFriends_GetFriendByIndex(self.friends, idx, flags.bits() as _).0);
+                let friend = SteamId(sys::SteamAPI_ISteamFriends_GetFriendByIndex(self.friends, idx, flags.bits() as _));
                 friends.push(Friend {
                     id: friend,
                     friends: self.friends,
@@ -93,7 +93,7 @@ impl <Manager> Friends<Manager> {
 
     pub fn request_user_information(&self, user: SteamId, name_only: bool) {
         unsafe {
-            sys::SteamAPI_ISteamFriends_RequestUserInformation(self.friends, sys::CSteamID(user.0), name_only as u8);
+            sys::SteamAPI_ISteamFriends_RequestUserInformation(self.friends, user.0, name_only);
         }
     }
 
@@ -101,14 +101,18 @@ impl <Manager> Friends<Manager> {
     pub fn activate_game_overlay_to_web_page(&self, url: &str) {
         unsafe {
             let url = CString::new(url).unwrap();
-            sys::SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage(self.friends, url.as_ptr() as *const _);
+            sys::SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage(
+                self.friends,
+                url.as_ptr() as *const _,
+                sys::EActivateGameOverlayToWebPageMode::k_EActivateGameOverlayToWebPageMode_Default
+            );
         }
     }
 
     /// Opens up an invite dialog for the given lobby
     pub fn activate_invite_dialog(&self, lobby: LobbyId) {
         unsafe {
-            sys::SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialog(self.friends, sys::CSteamID(lobby.0));
+            sys::SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialog(self.friends, lobby.0);
         }
     }
 }
@@ -164,8 +168,8 @@ unsafe impl Callback for GameLobbyJoinRequested {
     unsafe fn from_raw(raw: *mut libc::c_void) -> Self {
         let val = &mut *(raw as *mut sys::GameLobbyJoinRequested_t);
         GameLobbyJoinRequested {
-            lobby_steam_id: LobbyId(val.m_steamIDLobby.0),
-            friend_steam_id: SteamId(val.m_steamIDFriend.0),
+            lobby_steam_id: LobbyId(val.m_steamIDLobby.m_steamid.m_unAll64Bits),
+            friend_steam_id: SteamId(val.m_steamIDFriend.m_steamid.m_unAll64Bits),
         }
     }
 }
@@ -189,7 +193,7 @@ impl <Manager> Friend<Manager> {
 
     pub fn name(&self) -> String {
         unsafe {
-            let name = sys::SteamAPI_ISteamFriends_GetFriendPersonaName(self.friends, sys::CSteamID(self.id.0));
+            let name = sys::SteamAPI_ISteamFriends_GetFriendPersonaName(self.friends, self.id.0);
             let name = CStr::from_ptr(name);
             name.to_string_lossy().into_owned()
         }
@@ -197,15 +201,15 @@ impl <Manager> Friend<Manager> {
 
     pub fn state(&self) -> FriendState {
         unsafe {
-            let state = sys::SteamAPI_ISteamFriends_GetFriendPersonaState(self.friends, sys::CSteamID(self.id.0));
+            let state = sys::SteamAPI_ISteamFriends_GetFriendPersonaState(self.friends, self.id.0);
             match state {
-                sys::EPersonaState::EPersonaStateOffline => FriendState::Offline,
-                sys::EPersonaState::EPersonaStateOnline => FriendState::Online,
-                sys::EPersonaState::EPersonaStateBusy => FriendState::Busy,
-                sys::EPersonaState::EPersonaStateAway => FriendState::Away,
-                sys::EPersonaState::EPersonaStateSnooze => FriendState::Snooze,
-                sys::EPersonaState::EPersonaStateLookingToPlay => FriendState::LookingToPlay,
-                sys::EPersonaState::EPersonaStateLookingToTrade => FriendState::LookingToTrade,
+                sys::EPersonaState::k_EPersonaStateOffline => FriendState::Offline,
+                sys::EPersonaState::k_EPersonaStateOnline => FriendState::Online,
+                sys::EPersonaState::k_EPersonaStateBusy => FriendState::Busy,
+                sys::EPersonaState::k_EPersonaStateAway => FriendState::Away,
+                sys::EPersonaState::k_EPersonaStateSnooze => FriendState::Snooze,
+                sys::EPersonaState::k_EPersonaStateLookingToPlay => FriendState::LookingToPlay,
+                sys::EPersonaState::k_EPersonaStateLookingToTrade => FriendState::LookingToTrade,
                 _ => unreachable!(),
             }
         }
@@ -215,13 +219,13 @@ impl <Manager> Friend<Manager> {
     pub fn game_played(&self) -> Option<FriendGame> {
         unsafe {
             let mut info: sys::FriendGameInfo_t = std::mem::zeroed();
-            if sys::SteamAPI_ISteamFriends_GetFriendGamePlayed(self.friends, sys::CSteamID(self.id.0), &mut info) != 0 {
+            if sys::SteamAPI_ISteamFriends_GetFriendGamePlayed(self.friends, self.id.0, &mut info) {
                 Some(FriendGame {
-                    game: GameId(info.m_gameID.0),
+                    game: GameId(std::mem::transmute(info.m_gameID)),
                     game_address: info.m_unGameIP.into(),
                     game_port: info.m_usGamePort,
                     query_port: info.m_usQueryPort,
-                    lobby: LobbyId(info.m_steamIDLobby.0),
+                    lobby: LobbyId(info.m_steamIDLobby.m_steamid.m_unAll64Bits),
                 })
             } else {
                 None
@@ -232,20 +236,20 @@ impl <Manager> Friend<Manager> {
     /// Returns a small (32x32) avatar for the user in RGBA format
     pub fn small_avatar(&self) -> Option<Vec<u8>> {
         unsafe {
-            let utils = sys::steam_rust_get_utils();
-            let img = sys::SteamAPI_ISteamFriends_GetSmallFriendAvatar(self.friends, sys::CSteamID(self.id.0));
+            let utils = sys::SteamAPI_SteamUtils_v009();
+            let img = sys::SteamAPI_ISteamFriends_GetSmallFriendAvatar(self.friends, self.id.0);
             if img == 0 {
                 return None;
             }
             let mut width = 0;
             let mut height = 0;
-            if sys::SteamAPI_ISteamUtils_GetImageSize(utils, img, &mut width, &mut height) == 0 {
+            if !sys::SteamAPI_ISteamUtils_GetImageSize(utils, img, &mut width, &mut height) {
                 return None;
             }
             assert_eq!(width, 32);
             assert_eq!(height, 32);
             let mut dest = vec![0; 32 * 32 * 4];
-            if sys::SteamAPI_ISteamUtils_GetImageRGBA(utils, img, dest.as_mut_ptr(), 32 * 32 * 4) == 0 {
+            if !sys::SteamAPI_ISteamUtils_GetImageRGBA(utils, img, dest.as_mut_ptr(), 32 * 32 * 4) {
                 return None;
             }
             Some(dest)
@@ -255,20 +259,20 @@ impl <Manager> Friend<Manager> {
     /// Returns a medium (64x64) avatar for the user in RGBA format
     pub fn medium_avatar(&self) -> Option<Vec<u8>> {
         unsafe {
-            let utils = sys::steam_rust_get_utils();
-            let img = sys::SteamAPI_ISteamFriends_GetMediumFriendAvatar(self.friends, sys::CSteamID(self.id.0));
+            let utils = sys::SteamAPI_SteamUtils_v009();
+            let img = sys::SteamAPI_ISteamFriends_GetMediumFriendAvatar(self.friends, self.id.0);
             if img == 0 {
                 return None;
             }
             let mut width = 0;
             let mut height = 0;
-            if sys::SteamAPI_ISteamUtils_GetImageSize(utils, img, &mut width, &mut height) == 0 {
+            if !sys::SteamAPI_ISteamUtils_GetImageSize(utils, img, &mut width, &mut height) {
                 return None;
             }
             assert_eq!(width, 64);
             assert_eq!(height, 64);
             let mut dest = vec![0; 64 * 64 * 4];
-            if sys::SteamAPI_ISteamUtils_GetImageRGBA(utils, img, dest.as_mut_ptr(), 64 * 64 * 4) == 0 {
+            if !sys::SteamAPI_ISteamUtils_GetImageRGBA(utils, img, dest.as_mut_ptr(), 64 * 64 * 4) {
                 return None;
             }
             Some(dest)
diff --git a/src/lib.rs b/src/lib.rs
index a041ac6..f7bd223 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -59,14 +59,12 @@ pub type SResult<T> = Result<T, SteamError>;
 /// clients can use.
 pub struct Client<Manager = ClientManager> {
     inner: Arc<Inner<Manager>>,
-    client: *mut sys::ISteamClient,
 }
 
 impl <Manager> Clone for Client<Manager> {
     fn clone(&self) -> Self {
         Client {
             inner: self.inner.clone(),
-            client: self.client,
         }
     }
 }
@@ -74,7 +72,7 @@ impl <Manager> Clone for Client<Manager> {
 /// Allows access parts of the steam api that can only be called
 /// on a single thread at any given time.
 pub struct SingleClient<Manager = ClientManager> {
-    _inner: Arc<Inner<Manager>>,
+    inner: Arc<Inner<Manager>>,
     _not_sync: PhantomData<*mut ()>,
 }
 
@@ -84,8 +82,8 @@ struct Inner<Manager> {
 }
 
 struct Callbacks {
-    callbacks: Vec<*mut libc::c_void>,
-    call_results: HashMap<sys::SteamAPICall_t, *mut libc::c_void>,
+    callbacks: HashMap<i32, Box<dyn FnMut(*mut libc::c_void) + Send + 'static>>,
+    call_results: HashMap<sys::SteamAPICall_t, Box<dyn FnMut(*mut libc::c_void, bool) + Send + 'static>>,
 }
 
 unsafe impl <Manager: Send + Sync> Send for Inner<Manager> {}
@@ -101,7 +99,7 @@ unsafe impl <Manager: Send + Sync> Send for SingleClient<Manager> {}
 /// or has a `steam_appid.txt`
 pub fn restart_app_if_necessary(app_id: AppId) -> bool {
     unsafe {
-        sys::SteamAPI_RestartAppIfNecessary(app_id.0) != 0
+        sys::SteamAPI_RestartAppIfNecessary(app_id.0)
     }
 }
 
@@ -131,22 +129,21 @@ impl Client<ClientManager> {
         static_assert_sync::<Client<ClientManager>>();
         static_assert_send::<SingleClient<ClientManager>>();
         unsafe {
-            if sys::SteamAPI_Init() == 0 {
+            if !sys::SteamAPI_Init() {
                 return Err(SteamError::InitFailed);
             }
-            let raw_client = sys::steam_rust_get_client();
+            sys::SteamAPI_ManualDispatch_Init();
             let client = Arc::new(Inner {
                 _manager: ClientManager { _priv: () },
                 callbacks: Mutex::new(Callbacks {
-                    callbacks: Vec::new(),
+                    callbacks: HashMap::new(),
                     call_results: HashMap::new(),
                 }),
             });
             Ok((Client {
                 inner: client.clone(),
-                client: raw_client,
             }, SingleClient {
-                _inner: client,
+                inner: client,
                 _not_sync: PhantomData,
             }))
         }
@@ -162,7 +159,31 @@ impl <M> SingleClient<M> where M: Manager {
     /// in order to reduce the latency between recieving events.
     pub fn run_callbacks(&self) {
         unsafe {
-            M::run_callbacks();
+            let pipe = M::get_pipe();
+            sys::SteamAPI_ManualDispatch_RunFrame(pipe);
+            let mut callback = std::mem::zeroed();
+            while sys::SteamAPI_ManualDispatch_GetNextCallback(pipe, &mut callback) {
+                let mut callbacks = self.inner.callbacks.lock().unwrap();
+                if callback.m_iCallback == sys::SteamAPICallCompleted_t_k_iCallback as i32 {
+                    let apicall = &mut *(callback.m_pubParam as *mut _ as *mut sys::SteamAPICallCompleted_t);
+                    let mut apicall_result = vec![0; apicall.m_cubParam as usize];
+                    let mut failed = false;
+                    if sys::SteamAPI_ManualDispatch_GetAPICallResult(
+                        pipe, apicall.m_hAsyncCall,
+                        apicall_result.as_mut_ptr() as *mut _, apicall.m_cubParam as _,
+                        apicall.m_iCallback, &mut failed
+                    ) {
+                        if let Some(mut cb) = callbacks.call_results.remove(&apicall.m_hAsyncCall) {
+                            cb(apicall_result.as_mut_ptr() as *mut _, failed);
+                        }
+                    }
+                } else {
+                    if let Some(cb) = callbacks.callbacks.get_mut(&callback.m_iCallback) {
+                        cb(callback.m_pubParam as *mut _);
+                    }
+                }
+                sys::SteamAPI_ManualDispatch_FreeLastCallback(pipe);
+            }
         }
     }
 }
@@ -185,7 +206,7 @@ impl <Manager> Client<Manager> {
     /// Returns an accessor to the steam utils interface
     pub fn utils(&self) -> Utils<Manager> {
         unsafe {
-            let utils = sys::steam_rust_get_utils();
+            let utils = sys::SteamAPI_SteamUtils_v009();
             debug_assert!(!utils.is_null());
             Utils {
                 utils: utils,
@@ -197,7 +218,7 @@ impl <Manager> Client<Manager> {
     /// Returns an accessor to the steam matchmaking interface
     pub fn matchmaking(&self) -> Matchmaking<Manager> {
         unsafe {
-            let mm = sys::steam_rust_get_matchmaking();
+            let mm = sys::SteamAPI_SteamMatchmaking_v009();
             debug_assert!(!mm.is_null());
             Matchmaking {
                 mm: mm,
@@ -209,7 +230,7 @@ impl <Manager> Client<Manager> {
     /// Returns an accessor to the steam networking interface
     pub fn networking(&self) -> Networking<Manager> {
         unsafe {
-            let net = sys::steam_rust_get_networking();
+            let net = sys::SteamAPI_SteamNetworking_v006();
             debug_assert!(!net.is_null());
             Networking {
                 net: net,
@@ -221,7 +242,7 @@ impl <Manager> Client<Manager> {
     /// Returns an accessor to the steam apps interface
     pub fn apps(&self) -> Apps<Manager> {
         unsafe {
-            let apps = sys::steam_rust_get_apps();
+            let apps = sys::SteamAPI_SteamApps_v008();
             debug_assert!(!apps.is_null());
             Apps {
                 apps: apps,
@@ -233,7 +254,7 @@ impl <Manager> Client<Manager> {
     /// Returns an accessor to the steam friends interface
     pub fn friends(&self) -> Friends<Manager> {
         unsafe {
-            let friends = sys::steam_rust_get_friends();
+            let friends = sys::SteamAPI_SteamFriends_v017();
             debug_assert!(!friends.is_null());
             Friends {
                 friends: friends,
@@ -246,7 +267,7 @@ impl <Manager> Client<Manager> {
     /// Returns an accessor to the steam user interface
     pub fn user(&self) -> User<Manager> {
         unsafe {
-            let user = sys::steam_rust_get_user();
+            let user = sys::SteamAPI_SteamUser_v020();
             debug_assert!(!user.is_null());
             User {
                 user,
@@ -258,7 +279,7 @@ impl <Manager> Client<Manager> {
     /// Returns an accessor to the steam user stats interface
     pub fn user_stats(&self) -> UserStats<Manager> {
         unsafe {
-            let us = sys::steam_rust_get_user_stats();
+            let us = sys::SteamAPI_SteamUserStats_v011();
             debug_assert!(!us.is_null());
             UserStats {
                 user_stats: us,
@@ -270,9 +291,9 @@ impl <Manager> Client<Manager> {
     /// Returns an accessor to the steam remote storage interface
     pub fn remote_storage(&self) -> RemoteStorage<Manager> {
         unsafe {
-            let rs = sys::steam_rust_get_remote_storage();
+            let rs = sys::SteamAPI_SteamRemoteStorage_v014();
             debug_assert!(!rs.is_null());
-            let util = sys::steam_rust_get_utils();
+            let util = sys::SteamAPI_SteamUtils_v009();
             debug_assert!(!util.is_null());
             RemoteStorage {
                 rs,
@@ -285,7 +306,7 @@ impl <Manager> Client<Manager> {
     /// Returns an accessor to the steam UGC interface (steam workshop)
     pub fn ugc(&self) -> UGC<Manager> {
         unsafe {
-            let ugc = sys::steam_rust_get_ugc();
+            let ugc = sys::SteamAPI_SteamUGC_v014();
             debug_assert!(!ugc.is_null());
             UGC {
                 ugc,
@@ -295,25 +316,9 @@ impl <Manager> Client<Manager> {
     }
 }
 
-impl <Manager> Drop for Inner<Manager> {
-    fn drop(&mut self) {
-        unsafe {
-            {
-                let callbacks = self.callbacks.lock().unwrap();
-                for cb in &callbacks.callbacks {
-                    sys::delete_rust_callback(*cb);
-                }
-                for cb in callbacks.call_results.values() {
-                    sys::delete_rust_callback(*cb);
-                }
-            }
-        }
-    }
-}
-
 /// Used to separate client and game server modes
 pub unsafe trait Manager {
-    unsafe fn run_callbacks();
+    unsafe fn get_pipe() -> sys::HSteamPipe;
 }
 
 /// Manages keeping the steam api active for clients
@@ -322,8 +327,8 @@ pub struct ClientManager {
 }
 
 unsafe impl Manager for ClientManager {
-    unsafe fn run_callbacks() {
-        sys::SteamAPI_RunCallbacks();
+    unsafe fn get_pipe() -> sys::HSteamPipe {
+        sys::SteamAPI_GetHSteamPipe()
     }
 }
 
@@ -357,17 +362,13 @@ impl SteamId {
         self.0
     }
 
-    /// Returns whether this id is valid or not
-    pub fn is_valid(&self) -> bool {
-        unsafe {
-            sys::steam_rust_is_steam_id_valid(self.0) != 0
-        }
-    }
-
     /// Returns the account id for this steam id
     pub fn account_id(&self) -> AccountId {
         unsafe {
-            AccountId(sys::steam_rust_get_account_id_from_steam_id(self.0).0)
+            let bits = sys::CSteamID_SteamID_t {
+                m_unAll64Bits: self.0,
+            };
+            AccountId(bits.m_comp.m_unAccountID())
         }
     }
 }
@@ -403,16 +404,8 @@ impl GameId {
 
     /// Returns the app id of this game
     pub fn app_id(&self) -> AppId {
-        unsafe {
-            AppId(sys::steam_rust_get_game_id_app(self.0))
-        }
-    }
-
-    /// Returns whether this id is valid or not
-    pub fn is_valid(&self) -> bool {
-        unsafe {
-            sys::steam_rust_is_game_id_valid(self.0) != 0
-        }
+        // TODO: Relies on internal details
+        AppId((self.0 & 0xFF_FF_FF) as u32)
     }
 }
 
diff --git a/src/matchmaking.rs b/src/matchmaking.rs
index f10eff1..ed4cd57 100644
--- a/src/matchmaking.rs
+++ b/src/matchmaking.rs
@@ -40,13 +40,6 @@ impl LobbyId {
     pub fn raw(&self) -> u64 {
         self.0
     }
-
-    /// Returns whether this id is valid or not
-    pub fn is_valid(&self) -> bool {
-        unsafe {
-            sys::steam_rust_is_steam_id_valid(self.0) != 0
-        }
-    }
 }
 
 impl <Manager> Matchmaking<Manager> {
@@ -64,7 +57,7 @@ impl <Manager> Matchmaking<Manager> {
                     } else {
                         let mut out = Vec::with_capacity(v.m_nLobbiesMatching as usize);
                         for idx in 0 .. v.m_nLobbiesMatching {
-                            out.push(LobbyId(sys::SteamAPI_ISteamMatchmaking_GetLobbyByIndex(sys::steam_rust_get_matchmaking(), idx as _).0));
+                            out.push(LobbyId(sys::SteamAPI_ISteamMatchmaking_GetLobbyByIndex(sys::SteamAPI_SteamMatchmaking_v009(), idx as _)));
                         }
                         Ok(out)
                     })
@@ -89,10 +82,10 @@ impl <Manager> Matchmaking<Manager> {
         assert!(max_members <= 250); // Steam API limits
         unsafe {
             let ty = match ty {
-                LobbyType::Private => sys::ELobbyType::ELobbyTypePrivate,
-                LobbyType::FriendsOnly => sys::ELobbyType::ELobbyTypeFriendsOnly,
-                LobbyType::Public => sys::ELobbyType::ELobbyTypePublic,
-                LobbyType::Invisible => sys::ELobbyType::ELobbyTypeInvisible,
+                LobbyType::Private => sys::ELobbyType::k_ELobbyTypePrivate,
+                LobbyType::FriendsOnly => sys::ELobbyType::k_ELobbyTypeFriendsOnly,
+                LobbyType::Public => sys::ELobbyType::k_ELobbyTypePublic,
+                LobbyType::Invisible => sys::ELobbyType::k_ELobbyTypeInvisible,
             };
             let api_call = sys::SteamAPI_ISteamMatchmaking_CreateLobby(self.mm, ty, max_members as _);
             register_call_result::<sys::LobbyCreated_t, _, _>(
@@ -100,7 +93,7 @@ impl <Manager> Matchmaking<Manager> {
                 move |v, io_error| {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
-                    } else if v.m_eResult != sys::EResult::EResultOK {
+                    } else if v.m_eResult != sys::EResult::k_EResultOK {
                         Err(v.m_eResult.into())
                     } else {
                         Ok(LobbyId(v.m_ulSteamIDLobby))
@@ -115,7 +108,7 @@ impl <Manager> Matchmaking<Manager> {
         where F: FnMut(Result<LobbyId, ()>) + 'static + Send
     {
         unsafe {
-            let api_call = sys::SteamAPI_ISteamMatchmaking_JoinLobby(self.mm, sys::CSteamID(lobby.0));
+            let api_call = sys::SteamAPI_ISteamMatchmaking_JoinLobby(self.mm, lobby.0);
             register_call_result::<sys::LobbyEnter_t, _, _>(
                 &self.inner, api_call, CALLBACK_BASE_ID + 4,
                 move |v, io_error| {
@@ -134,14 +127,14 @@ impl <Manager> Matchmaking<Manager> {
     /// Exits the passed lobby
     pub fn leave_lobby(&self, lobby: LobbyId) {
         unsafe {
-            sys::SteamAPI_ISteamMatchmaking_LeaveLobby(self.mm, sys::CSteamID(lobby.0));
+            sys::SteamAPI_ISteamMatchmaking_LeaveLobby(self.mm, lobby.0);
         }
     }
 
     /// Returns the steam id of the current owner of the passed lobby
     pub fn lobby_owner(&self, lobby: LobbyId) -> SteamId {
         unsafe {
-            SteamId(sys::SteamAPI_ISteamMatchmaking_GetLobbyOwner(self.mm, sys::CSteamID(lobby.0)).0)
+            SteamId(sys::SteamAPI_ISteamMatchmaking_GetLobbyOwner(self.mm, lobby.0))
         }
     }
 
@@ -150,7 +143,7 @@ impl <Manager> Matchmaking<Manager> {
     /// Useful if you are not currently in the lobby
     pub fn lobby_member_count(&self, lobby: LobbyId) -> usize  {
         unsafe {
-            let count = sys::SteamAPI_ISteamMatchmaking_GetNumLobbyMembers(self.mm, sys::CSteamID(lobby.0));
+            let count = sys::SteamAPI_ISteamMatchmaking_GetNumLobbyMembers(self.mm, lobby.0);
             count as usize
         }
     }
@@ -158,11 +151,11 @@ impl <Manager> Matchmaking<Manager> {
     /// Returns a list of members currently in the lobby
     pub fn lobby_members(&self, lobby: LobbyId) -> Vec<SteamId> {
         unsafe {
-            let count = sys::SteamAPI_ISteamMatchmaking_GetNumLobbyMembers(self.mm, sys::CSteamID(lobby.0));
+            let count = sys::SteamAPI_ISteamMatchmaking_GetNumLobbyMembers(self.mm, lobby.0);
             let mut members = Vec::with_capacity(count as usize);
             for idx in 0 .. count {
                 members.push(SteamId(
-                    sys::SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex(self.mm, sys::CSteamID(lobby.0), idx).0
+                    sys::SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex(self.mm, lobby.0, idx)
                 ))
             }
             members
@@ -181,8 +174,8 @@ impl <Manager> Matchmaking<Manager> {
     pub fn set_lobby_joinable(&self, lobby: LobbyId, joinable: bool) -> bool {
         unsafe {
             sys::SteamAPI_ISteamMatchmaking_SetLobbyJoinable(
-                self.mm, sys::CSteamID(lobby.0), joinable
-            ) != 0
+                self.mm, lobby.0, joinable
+            )
         }
     }
 }
diff --git a/src/networking.rs b/src/networking.rs
index 82fe1e7..346f9ee 100644
--- a/src/networking.rs
+++ b/src/networking.rs
@@ -32,14 +32,14 @@ impl <Manager> Networking<Manager> {
     /// Should only be called in response to a `P2PSessionRequest`.
     pub fn accept_p2p_session(&self, user: SteamId) {
         unsafe {
-            sys::SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser(self.net, sys::CSteamID(user.0));
+            sys::SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser(self.net, user.0);
         }
     }
 
     /// Closes the p2p connection between the given user
     pub fn close_p2p_session(&self, user: SteamId) {
         unsafe {
-            sys::SteamAPI_ISteamNetworking_CloseP2PSessionWithUser(self.net, sys::CSteamID(user.0));
+            sys::SteamAPI_ISteamNetworking_CloseP2PSessionWithUser(self.net, user.0);
         }
     }
 
@@ -48,12 +48,12 @@ impl <Manager> Networking<Manager> {
     pub fn send_p2p_packet(&self, remote: SteamId, send_type: SendType, data: &[u8]) -> bool {
         unsafe {
             let send_type = match send_type {
-                SendType::Unreliable => sys::EP2PSend::EP2PSendUnreliable,
-                SendType::UnreliableNoDelay => sys::EP2PSend::EP2PSendUnreliableNoDelay,
-                SendType::Reliable => sys::EP2PSend::EP2PSendReliable,
-                SendType::ReliableWithBuffering => sys::EP2PSend::EP2PSendReliableWithBuffering,
+                SendType::Unreliable => sys::EP2PSend::k_EP2PSendUnreliable,
+                SendType::UnreliableNoDelay => sys::EP2PSend::k_EP2PSendUnreliableNoDelay,
+                SendType::Reliable => sys::EP2PSend::k_EP2PSendReliable,
+                SendType::ReliableWithBuffering => sys::EP2PSend::k_EP2PSendReliableWithBuffering,
             };
-            sys::SteamAPI_ISteamNetworking_SendP2PPacket(self.net, sys::CSteamID(remote.0), data.as_ptr() as *const _, data.len() as u32, send_type, 0) != 0
+            sys::SteamAPI_ISteamNetworking_SendP2PPacket(self.net, remote.0, data.as_ptr() as *const _, data.len() as u32, send_type, 0)
         }
     }
 
@@ -63,7 +63,7 @@ impl <Manager> Networking<Manager> {
     pub fn is_p2p_packet_available(&self) -> Option<usize> {
         unsafe {
             let mut size = 0;
-            if sys::SteamAPI_ISteamNetworking_IsP2PPacketAvailable(self.net, &mut size, 0) != 0 {
+            if sys::SteamAPI_ISteamNetworking_IsP2PPacketAvailable(self.net, &mut size, 0) {
                 Some(size as usize)
             } else {
                 None
@@ -79,9 +79,9 @@ impl <Manager> Networking<Manager> {
     pub fn read_p2p_packet(&self, buf: &mut [u8]) -> Option<(SteamId, usize)> {
         unsafe {
             let mut size = 0;
-            let mut remote = sys::CSteamID(0);
-            if sys::SteamAPI_ISteamNetworking_ReadP2PPacket(self.net, buf.as_mut_ptr() as *mut _, buf.len() as _, &mut size, &mut remote, 0) != 0 {
-                Some((SteamId(remote.0), size as usize))
+            let mut remote = 0;
+            if sys::SteamAPI_ISteamNetworking_ReadP2PPacket(self.net, buf.as_mut_ptr() as *mut _, buf.len() as _, &mut size, &mut remote as *mut _ as *mut _, 0) {
+                Some((SteamId(remote), size as usize))
             } else {
                 None
             }
@@ -105,7 +105,7 @@ unsafe impl Callback for P2PSessionRequest {
     unsafe fn from_raw(raw: *mut libc::c_void) -> Self {
         let val = &mut *(raw as *mut sys::P2PSessionRequest_t);
         P2PSessionRequest {
-            remote: SteamId(val.m_steamIDRemote.0),
+            remote: SteamId(val.m_steamIDRemote.m_steamid.m_unAll64Bits),
         }
     }
 }
@@ -124,7 +124,7 @@ unsafe impl Callback for P2PSessionConnectFail {
     unsafe fn from_raw(raw: *mut libc::c_void) -> Self {
         let val = &mut *(raw as *mut sys::P2PSessionConnectFail_t);
         P2PSessionConnectFail {
-            remote: SteamId(val.m_steamIDRemote.0),
+            remote: SteamId(val.m_steamIDRemote.m_steamid.m_unAll64Bits),
             error: val.m_eP2PSessionError,
         }
     }
diff --git a/src/remote_storage.rs b/src/remote_storage.rs
index 0772ca8..c99a719 100644
--- a/src/remote_storage.rs
+++ b/src/remote_storage.rs
@@ -211,7 +211,7 @@ impl <Manager> std::io::Read for SteamFileReader<Manager> {
             let mut callback: sys::RemoteStorageFileReadAsyncComplete_t = std::mem::zeroed();
             sys::SteamAPI_ISteamUtils_GetAPICallResult(self.file.util, api_call, (&mut callback) as *mut _ as *mut _, std::mem::size_of::<sys::RemoteStorageFileReadAsyncComplete_t>() as _, 1332, &mut failed);
 
-            if callback.m_eResult != sys::EResult::EResultOK {
+            if callback.m_eResult != sys::EResult::k_EResultOK {
                 return Err(std::io::ErrorKind::Other.into());
             }
             let size = callback.m_cubRead as usize;
diff --git a/src/server.rs b/src/server.rs
index f178d28..92e7a4f 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -63,23 +63,23 @@ impl Server {
             let version = CString::new(version).unwrap();
             let raw_ip: u32 = ip.into();
             let server_mode = match server_mode {
-                ServerMode::NoAuthentication => sys::EServerMode::ServerModeNoAuthentication,
-                ServerMode::Authentication => sys::EServerMode::ServerModeAuthentication,
-                ServerMode::AuthenticationAndSecure => sys::EServerMode::ServerModeAuthenticationAndSecure,
+                ServerMode::NoAuthentication => sys::EServerMode::eServerModeNoAuthentication,
+                ServerMode::Authentication => sys::EServerMode::eServerModeAuthentication,
+                ServerMode::AuthenticationAndSecure => sys::EServerMode::eServerModeAuthenticationAndSecure,
             };
-            if sys::steam_rust_game_server_init(
+            if !sys::SteamInternal_GameServer_Init(
                 raw_ip, steam_port,
                 game_port, query_port,
                 server_mode,
                 version.as_ptr(),
-            ) == 0 {
+            ) {
                 return Err(SteamError::InitFailed);
             }
-            let server_raw = sys::steam_rust_get_server();
+            let server_raw = sys::SteamAPI_SteamGameServer_v013();
             let server = Arc::new(Inner {
                 _manager: ServerManager { _priv: () },
                 callbacks: Mutex::new(Callbacks {
-                    callbacks: Vec::new(),
+                    callbacks: HashMap::new(),
                     call_results: HashMap::new(),
                 }),
             });
@@ -87,7 +87,7 @@ impl Server {
                 inner: server.clone(),
                 server: server_raw,
             }, SingleClient {
-                _inner: server,
+                inner: server,
                 _not_sync: PhantomData,
             }))
         }
@@ -110,7 +110,7 @@ impl Server {
     /// Returns the steam id of the current server
     pub fn steam_id(&self) -> SteamId {
         unsafe {
-            SteamId(sys::SteamAPI_ISteamGameServer_GetSteamID(self.server).0)
+            SteamId(sys::SteamAPI_ISteamGameServer_GetSteamID(self.server))
         }
     }
 
@@ -159,15 +159,16 @@ impl Server {
             let res = sys::SteamAPI_ISteamGameServer_BeginAuthSession(
                 self.server,
                 ticket.as_ptr() as *const _, ticket.len() as _,
-                sys::CSteamID(user.0)
+                user.0
             );
             Err(match res {
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultOK => return Ok(()),
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultInvalidTicket => AuthSessionError::InvalidTicket,
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultDuplicateRequest => AuthSessionError::DuplicateRequest,
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultInvalidVersion => AuthSessionError::InvalidVersion,
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultGameMismatch => AuthSessionError::GameMismatch,
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultExpiredTicket => AuthSessionError::ExpiredTicket,
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultOK => return Ok(()),
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultInvalidTicket => AuthSessionError::InvalidTicket,
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultDuplicateRequest => AuthSessionError::DuplicateRequest,
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultInvalidVersion => AuthSessionError::InvalidVersion,
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultGameMismatch => AuthSessionError::GameMismatch,
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultExpiredTicket => AuthSessionError::ExpiredTicket,
+                _ => unreachable!(),
             })
         }
     }
@@ -179,7 +180,7 @@ impl Server {
     /// the specified entity.
     pub fn end_authentication_session(&self, user: SteamId) {
         unsafe {
-            sys::SteamAPI_ISteamGameServer_EndAuthSession(self.server, sys::CSteamID(user.0));
+            sys::SteamAPI_ISteamGameServer_EndAuthSession(self.server, user.0);
         }
     }
 
@@ -209,7 +210,7 @@ impl Server {
     /// Sets whether this server is dedicated or a listen server.
     pub fn set_dedicated_server(&self, dedicated: bool) {
         unsafe {
-            sys::SteamAPI_ISteamGameServer_SetDedicatedServer(self.server, dedicated as u8);
+            sys::SteamAPI_ISteamGameServer_SetDedicatedServer(self.server, dedicated);
         }
     }
 
@@ -328,8 +329,8 @@ pub struct ServerManager {
 }
 
 unsafe impl Manager for ServerManager {
-    unsafe fn run_callbacks() {
-        sys::SteamGameServer_RunCallbacks();
+    unsafe fn get_pipe() -> sys::HSteamPipe {
+        sys::SteamGameServer_GetHSteamPipe()
     }
 }
 
diff --git a/src/ugc.rs b/src/ugc.rs
index b54745f..78ae003 100644
--- a/src/ugc.rs
+++ b/src/ugc.rs
@@ -46,20 +46,20 @@ pub enum UGCType {
 impl Into<sys::EUGCMatchingUGCType> for UGCType {
     fn into(self) -> sys::EUGCMatchingUGCType {
         match self {
-            UGCType::Items => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_Items,
-            UGCType::ItemsMtx => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_Items_Mtx,
-            UGCType::ItemsReadyToUse => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_Items_ReadyToUse,
-            UGCType::Collections => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_Collections,
-            UGCType::Artwork => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_Artwork,
-            UGCType::Videos => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_Videos,
-            UGCType::Screenshots => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_Screenshots,
-            UGCType::AllGuides => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_AllGuides,
-            UGCType::WebGuides => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_WebGuides,
-            UGCType::IntegratedGuides => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_IntegratedGuides,
-            UGCType::UsableInGame => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_UsableInGame,
-            UGCType::ControllerBindings => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_ControllerBindings,
-            UGCType::GameManagedItems => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_GameManagedItems,
-            UGCType::All => sys::EUGCMatchingUGCType::EUGCMatchingUGCType_All,
+            UGCType::Items => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_Items,
+            UGCType::ItemsMtx => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_Items_Mtx,
+            UGCType::ItemsReadyToUse => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_Items_ReadyToUse,
+            UGCType::Collections => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_Collections,
+            UGCType::Artwork => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_Artwork,
+            UGCType::Videos => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_Videos,
+            UGCType::Screenshots => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_Screenshots,
+            UGCType::AllGuides => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_AllGuides,
+            UGCType::WebGuides => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_WebGuides,
+            UGCType::IntegratedGuides => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_IntegratedGuides,
+            UGCType::UsableInGame => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_UsableInGame,
+            UGCType::ControllerBindings => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_ControllerBindings,
+            UGCType::GameManagedItems => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_GameManagedItems,
+            UGCType::All => sys::EUGCMatchingUGCType::k_EUGCMatchingUGCType_All,
         }
     }
 }
@@ -87,22 +87,22 @@ pub enum FileType {
 impl Into<sys::EWorkshopFileType> for FileType {
     fn into(self) -> sys::EWorkshopFileType {
         match self {
-            FileType::Community => sys::EWorkshopFileType::EWorkshopFileTypeCommunity,
-            FileType::Microtransaction => sys::EWorkshopFileType::EWorkshopFileTypeMicrotransaction,
-            FileType::Collection => sys::EWorkshopFileType::EWorkshopFileTypeCollection,
-            FileType::Art => sys::EWorkshopFileType::EWorkshopFileTypeArt,
-            FileType::Video => sys::EWorkshopFileType::EWorkshopFileTypeVideo,
-            FileType::Screenshot => sys::EWorkshopFileType::EWorkshopFileTypeScreenshot,
-            FileType::Game => sys::EWorkshopFileType::EWorkshopFileTypeGame,
-            FileType::Software => sys::EWorkshopFileType::EWorkshopFileTypeSoftware,
-            FileType::Concept => sys::EWorkshopFileType::EWorkshopFileTypeConcept,
-            FileType::WebGuide => sys::EWorkshopFileType::EWorkshopFileTypeWebGuide,
-            FileType::IntegratedGuide => sys::EWorkshopFileType::EWorkshopFileTypeIntegratedGuide,
-            FileType::Merch => sys::EWorkshopFileType::EWorkshopFileTypeMerch,
-            FileType::ControllerBinding => sys::EWorkshopFileType::EWorkshopFileTypeControllerBinding,
-            FileType::SteamworksAccessInvite => sys::EWorkshopFileType::EWorkshopFileTypeSteamworksAccessInvite,
-            FileType::SteamVideo => sys::EWorkshopFileType::EWorkshopFileTypeSteamVideo,
-            FileType::GameManagedItem => sys::EWorkshopFileType::EWorkshopFileTypeGameManagedItem,
+            FileType::Community => sys::EWorkshopFileType::k_EWorkshopFileTypeCommunity,
+            FileType::Microtransaction => sys::EWorkshopFileType::k_EWorkshopFileTypeMicrotransaction,
+            FileType::Collection => sys::EWorkshopFileType::k_EWorkshopFileTypeCollection,
+            FileType::Art => sys::EWorkshopFileType::k_EWorkshopFileTypeArt,
+            FileType::Video => sys::EWorkshopFileType::k_EWorkshopFileTypeVideo,
+            FileType::Screenshot => sys::EWorkshopFileType::k_EWorkshopFileTypeScreenshot,
+            FileType::Game => sys::EWorkshopFileType::k_EWorkshopFileTypeGame,
+            FileType::Software => sys::EWorkshopFileType::k_EWorkshopFileTypeSoftware,
+            FileType::Concept => sys::EWorkshopFileType::k_EWorkshopFileTypeConcept,
+            FileType::WebGuide => sys::EWorkshopFileType::k_EWorkshopFileTypeWebGuide,
+            FileType::IntegratedGuide => sys::EWorkshopFileType::k_EWorkshopFileTypeIntegratedGuide,
+            FileType::Merch => sys::EWorkshopFileType::k_EWorkshopFileTypeMerch,
+            FileType::ControllerBinding => sys::EWorkshopFileType::k_EWorkshopFileTypeControllerBinding,
+            FileType::SteamworksAccessInvite => sys::EWorkshopFileType::k_EWorkshopFileTypeSteamworksAccessInvite,
+            FileType::SteamVideo => sys::EWorkshopFileType::k_EWorkshopFileTypeSteamVideo,
+            FileType::GameManagedItem => sys::EWorkshopFileType::k_EWorkshopFileTypeGameManagedItem,
         }
     }
 }
@@ -149,13 +149,13 @@ pub enum UserListOrder {
 impl Into<sys::EUserUGCListSortOrder> for UserListOrder {
     fn into(self) -> sys::EUserUGCListSortOrder {
         match self {
-            UserListOrder::CreationOrderAsc => sys::EUserUGCListSortOrder::EUserUGCListSortOrder_CreationOrderAsc,
-            UserListOrder::CreationOrderDesc => sys::EUserUGCListSortOrder::EUserUGCListSortOrder_CreationOrderDesc,
-            UserListOrder::TitleAsc => sys::EUserUGCListSortOrder::EUserUGCListSortOrder_TitleAsc,
-            UserListOrder::LastUpdatedDesc => sys::EUserUGCListSortOrder::EUserUGCListSortOrder_LastUpdatedDesc,
-            UserListOrder::SubscriptionDateDesc => sys::EUserUGCListSortOrder::EUserUGCListSortOrder_SubscriptionDateDesc,
-            UserListOrder::VoteScoreDesc => sys::EUserUGCListSortOrder::EUserUGCListSortOrder_VoteScoreDesc,
-            UserListOrder::ForModeration => sys::EUserUGCListSortOrder::EUserUGCListSortOrder_ForModeration,
+            UserListOrder::CreationOrderAsc => sys::EUserUGCListSortOrder::k_EUserUGCListSortOrder_CreationOrderAsc,
+            UserListOrder::CreationOrderDesc => sys::EUserUGCListSortOrder::k_EUserUGCListSortOrder_CreationOrderDesc,
+            UserListOrder::TitleAsc => sys::EUserUGCListSortOrder::k_EUserUGCListSortOrder_TitleAsc,
+            UserListOrder::LastUpdatedDesc => sys::EUserUGCListSortOrder::k_EUserUGCListSortOrder_LastUpdatedDesc,
+            UserListOrder::SubscriptionDateDesc => sys::EUserUGCListSortOrder::k_EUserUGCListSortOrder_SubscriptionDateDesc,
+            UserListOrder::VoteScoreDesc => sys::EUserUGCListSortOrder::k_EUserUGCListSortOrder_VoteScoreDesc,
+            UserListOrder::ForModeration => sys::EUserUGCListSortOrder::k_EUserUGCListSortOrder_ForModeration,
         }
     }
 }
@@ -188,15 +188,15 @@ impl Into<sys::EUserUGCList> for UserList {
     #[allow(deprecated)]
     fn into(self) -> sys::EUserUGCList {
         match self {
-            UserList::Published => sys::EUserUGCList::EUserUGCList_Published,
-            UserList::VotedOn => sys::EUserUGCList::EUserUGCList_VotedOn,
-            UserList::VotedUp => sys::EUserUGCList::EUserUGCList_VotedUp,
-            UserList::VotedDown => sys::EUserUGCList::EUserUGCList_VotedDown,
-            UserList::WillVoteLater => sys::EUserUGCList::EUserUGCList_WillVoteLater,
-            UserList::Favorited => sys::EUserUGCList::EUserUGCList_Favorited,
-            UserList::Subscribed => sys::EUserUGCList::EUserUGCList_Subscribed,
-            UserList::UsedOrPlayed => sys::EUserUGCList::EUserUGCList_UsedOrPlayed,
-            UserList::Followed => sys::EUserUGCList::EUserUGCList_Followed,
+            UserList::Published => sys::EUserUGCList::k_EUserUGCList_Published,
+            UserList::VotedOn => sys::EUserUGCList::k_EUserUGCList_VotedOn,
+            UserList::VotedUp => sys::EUserUGCList::k_EUserUGCList_VotedUp,
+            UserList::VotedDown => sys::EUserUGCList::k_EUserUGCList_VotedDown,
+            UserList::WillVoteLater => sys::EUserUGCList::k_EUserUGCList_WillVoteLater,
+            UserList::Favorited => sys::EUserUGCList::k_EUserUGCList_Favorited,
+            UserList::Subscribed => sys::EUserUGCList::k_EUserUGCList_Subscribed,
+            UserList::UsedOrPlayed => sys::EUserUGCList::k_EUserUGCList_UsedOrPlayed,
+            UserList::Followed => sys::EUserUGCList::k_EUserUGCList_Followed,
         }
     }
 }
@@ -226,10 +226,10 @@ unsafe impl Callback for Result<DownloadItemResult, SteamError> {
 
     unsafe fn from_raw(raw: *mut libc::c_void) -> Self {
         let val = &mut *(raw as *mut sys::DownloadItemResult_t);
-        if val.m_eResult == sys::EResult::EResultOK {
+        if val.m_eResult == sys::EResult::k_EResultOK {
             Ok(DownloadItemResult {
-                app_id: AppId(val.m_unAppID.0),
-                published_file_id: PublishedFileId(val.m_nPublishedFileId.0),
+                app_id: AppId(val.m_unAppID),
+                published_file_id: PublishedFileId(val.m_nPublishedFileId),
             })
         } else {
             Err(val.m_eResult.into())
@@ -247,9 +247,9 @@ pub struct InstallInfo {
 
 impl <Manager> UGC<Manager> {
     /// Suspends or resumes all workshop downloads
-    pub fn suspend_download(&self, suspend: bool) {
+    pub fn suspend_downloads(&self, suspend: bool) {
         unsafe {
-            sys::SteamAPI_ISteamUGC_SuspendDownload(self.ugc, suspend);
+            sys::SteamAPI_ISteamUGC_SuspendDownloads(self.ugc, suspend);
         }
     }
 
@@ -258,17 +258,17 @@ impl <Manager> UGC<Manager> {
         where F: FnMut(Result<(PublishedFileId, bool), SteamError>) + 'static + Send
     {
         unsafe {
-            let api_call = sys::SteamAPI_ISteamUGC_CreateItem(self.ugc, sys::AppId_t(app_id.0), file_type.into());
+            let api_call = sys::SteamAPI_ISteamUGC_CreateItem(self.ugc, app_id.0, file_type.into());
             register_call_result::<sys::CreateItemResult_t, _, _>(
                 &self.inner, api_call, CALLBACK_BASE_ID + 3,
                 move |v, io_error| {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
-                    } else if v.m_eResult != sys::EResult::EResultOK {
+                    } else if v.m_eResult != sys::EResult::k_EResultOK {
                         Err(v.m_eResult.into())
                     } else {
                         Ok((
-                            PublishedFileId(v.m_nPublishedFileId.0),
+                            PublishedFileId(v.m_nPublishedFileId),
                             v.m_bUserNeedsToAcceptWorkshopLegalAgreement,
                         ))
                     })
@@ -280,7 +280,7 @@ impl <Manager> UGC<Manager> {
     #[must_use]
     pub fn start_item_update(&self, app_id: AppId, file_id: PublishedFileId) -> UpdateHandle<Manager> {
         unsafe {
-            let handle = sys::SteamAPI_ISteamUGC_StartItemUpdate(self.ugc, sys::AppId_t(app_id.0), sys::PublishedFileId_t(file_id.0));
+            let handle = sys::SteamAPI_ISteamUGC_StartItemUpdate(self.ugc, app_id.0, file_id.0);
             UpdateHandle {
                 ugc: self.ugc,
                 inner: self.inner.clone(),
@@ -295,13 +295,13 @@ impl <Manager> UGC<Manager> {
         where F: FnMut(Result<(), SteamError>) + 'static + Send
     {
         unsafe {
-            let api_call = sys::SteamAPI_ISteamUGC_SubscribeItem(self.ugc, sys::PublishedFileId_t(published_file_id.0));
+            let api_call = sys::SteamAPI_ISteamUGC_SubscribeItem(self.ugc, published_file_id.0);
             register_call_result::<sys::RemoteStorageSubscribePublishedFileResult_t, _, _>(
                 &self.inner, api_call, CALLBACK_REMOTE_STORAGE_BASE_ID + 13,
                 move |v, io_error| {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
-                    } else if v.m_eResult != sys::EResult::EResultOK {
+                    } else if v.m_eResult != sys::EResult::k_EResultOK {
                         Err(v.m_eResult.into())
                     } else {
                         Ok(())
@@ -314,13 +314,13 @@ impl <Manager> UGC<Manager> {
         where F: FnMut(Result<(), SteamError>) + 'static + Send
     {
         unsafe {
-            let api_call = sys::SteamAPI_ISteamUGC_UnsubscribeItem(self.ugc, sys::PublishedFileId_t(published_file_id.0));
+            let api_call = sys::SteamAPI_ISteamUGC_UnsubscribeItem(self.ugc, published_file_id.0);
             register_call_result::<sys::RemoteStorageUnsubscribePublishedFileResult_t, _, _>(
                 &self.inner, api_call, CALLBACK_REMOTE_STORAGE_BASE_ID + 15,
                 move |v, io_error| {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
-                    } else if v.m_eResult != sys::EResult::EResultOK {
+                    } else if v.m_eResult != sys::EResult::k_EResultOK {
                         Err(v.m_eResult.into())
                     } else {
                         Ok(())
@@ -333,18 +333,18 @@ impl <Manager> UGC<Manager> {
     pub fn subscribed_items(&self) -> Vec<PublishedFileId> {
         unsafe {
             let count = sys::SteamAPI_ISteamUGC_GetNumSubscribedItems(self.ugc);
-            let mut data: Vec<sys::PublishedFileId_t> = vec![sys::PublishedFileId_t(0); count as usize];
+            let mut data: Vec<sys::PublishedFileId_t> = vec![0; count as usize];
             let gotten_count = sys::SteamAPI_ISteamUGC_GetSubscribedItems(self.ugc, data.as_mut_ptr(), count);
             debug_assert!(count == gotten_count);
             data.into_iter()
-                .map(|v| PublishedFileId(v.0))
+                .map(|v| PublishedFileId(v))
                 .collect()
         }
     }
 
     pub fn item_state(&self, item: PublishedFileId) -> ItemState {
         unsafe {
-            let state = sys::SteamAPI_ISteamUGC_GetItemState(self.ugc, sys::PublishedFileId_t(item.0));
+            let state = sys::SteamAPI_ISteamUGC_GetItemState(self.ugc, item.0);
             ItemState::from_bits_truncate(state)
         }
     }
@@ -353,7 +353,7 @@ impl <Manager> UGC<Manager> {
         unsafe {
             let mut current = 0u64;
             let mut total = 0u64;
-            if sys::SteamAPI_ISteamUGC_GetItemDownloadInfo(self.ugc, sys::PublishedFileId_t(item.0), &mut current, &mut total) {
+            if sys::SteamAPI_ISteamUGC_GetItemDownloadInfo(self.ugc, item.0, &mut current, &mut total) {
                 Some((current, total))
             } else {
                 None
@@ -366,7 +366,7 @@ impl <Manager> UGC<Manager> {
             let mut size_on_disk = 0u64;
             let mut folder = [0 as libc::c_char; 4096];
             let mut timestamp = 0u32;
-            if sys::SteamAPI_ISteamUGC_GetItemInstallInfo(self.ugc, sys::PublishedFileId_t(item.0), &mut size_on_disk, folder.as_mut_ptr(), folder.len() as _, &mut timestamp) {
+            if sys::SteamAPI_ISteamUGC_GetItemInstallInfo(self.ugc, item.0, &mut size_on_disk, folder.as_mut_ptr(), folder.len() as _, &mut timestamp) {
                 Some(InstallInfo {
                     folder: CStr::from_ptr(folder.as_ptr() as *const _ as *const _)
                         .to_string_lossy()
@@ -382,7 +382,7 @@ impl <Manager> UGC<Manager> {
 
     pub fn download_item(&self, item: PublishedFileId, high_priority: bool) -> bool {
         unsafe {
-            sys::SteamAPI_ISteamUGC_DownloadItem(self.ugc, sys::PublishedFileId_t(item.0), high_priority)
+            sys::SteamAPI_ISteamUGC_DownloadItem(self.ugc, item.0, high_priority)
         }
     }
 
@@ -398,15 +398,15 @@ impl <Manager> UGC<Manager> {
         unsafe {
             let res = sys::SteamAPI_ISteamUGC_CreateQueryUserUGCRequest(
                 self.ugc,
-                sys::AccountID_t(account.0),
+                account.0,
                 list_type.into(),
                 item_type.into(),
                 sort_order.into(),
-                sys::AppId_t(appids.creator_app_id().unwrap_or(AppId(0)).0),
-                sys::AppId_t(appids.consumer_app_id().unwrap_or(AppId(0)).0),
+                appids.creator_app_id().unwrap_or(AppId(0)).0,
+                appids.consumer_app_id().unwrap_or(AppId(0)).0,
                 page,
             );
-            if res.0 == UGCQueryHandleInvalid {
+            if res == UGCQueryHandleInvalid {
                 return Err(CreateQueryError);
             }
 
@@ -460,11 +460,11 @@ impl <Manager> UpdateHandle<Manager> {
                 move |v, io_error| {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
-                    } else if v.m_eResult != sys::EResult::EResultOK {
+                    } else if v.m_eResult != sys::EResult::k_EResultOK {
                         Err(v.m_eResult.into())
                     } else {
                         Ok((
-                            PublishedFileId(v.m_nPublishedFileId.0),
+                            PublishedFileId(v.m_nPublishedFileId),
                             v.m_bUserNeedsToAcceptWorkshopLegalAgreement,
                         ))
                     })
@@ -496,12 +496,13 @@ impl <Manager> UpdateWatchHandle<Manager> {
             let mut total = 0;
             let status = sys::SteamAPI_ISteamUGC_GetItemUpdateProgress(self.ugc, self.handle, &mut progress, &mut total);
             let status = match status {
-                sys::EItemUpdateStatus::EItemUpdateStatusInvalid => UpdateStatus::Invalid,
-                sys::EItemUpdateStatus::EItemUpdateStatusPreparingConfig => UpdateStatus::PreparingConfig,
-                sys::EItemUpdateStatus::EItemUpdateStatusPreparingContent => UpdateStatus::PreparingContent,
-                sys::EItemUpdateStatus::EItemUpdateStatusUploadingContent => UpdateStatus::UploadingContent,
-                sys::EItemUpdateStatus::EItemUpdateStatusUploadingPreviewFile => UpdateStatus::UploadingPreviewFile,
-                sys::EItemUpdateStatus::EItemUpdateStatusCommittingChanges => UpdateStatus::CommittingChanges,
+                sys::EItemUpdateStatus::k_EItemUpdateStatusInvalid => UpdateStatus::Invalid,
+                sys::EItemUpdateStatus::k_EItemUpdateStatusPreparingConfig => UpdateStatus::PreparingConfig,
+                sys::EItemUpdateStatus::k_EItemUpdateStatusPreparingContent => UpdateStatus::PreparingContent,
+                sys::EItemUpdateStatus::k_EItemUpdateStatusUploadingContent => UpdateStatus::UploadingContent,
+                sys::EItemUpdateStatus::k_EItemUpdateStatusUploadingPreviewFile => UpdateStatus::UploadingPreviewFile,
+                sys::EItemUpdateStatus::k_EItemUpdateStatusCommittingChanges => UpdateStatus::CommittingChanges,
+                _ => unreachable!(),
             };
             (status, progress, total)
         }
@@ -643,12 +644,12 @@ impl <Manager> UserListQuery<Manager> {
             register_call_result::<sys::SteamUGCQueryCompleted_t, _, _>(
                 &inner, api_call, CALLBACK_BASE_ID + 1,
                 move |v, io_error| {
-                    let ugc = sys::steam_rust_get_ugc();
+                    let ugc = sys::SteamAPI_SteamUGC_v014();
                     if io_error {
                         sys::SteamAPI_ISteamUGC_ReleaseQueryUGCRequest(ugc, handle);
                         cb(Err(SteamError::IOFailure));
                         return;
-                    } else if v.m_eResult != sys::EResult::EResultOK {
+                    } else if v.m_eResult != sys::EResult::k_EResultOK {
                         sys::SteamAPI_ISteamUGC_ReleaseQueryUGCRequest(ugc, handle);
                         cb(Err(v.m_eResult.into()));
                         return;
@@ -739,7 +740,7 @@ impl<'a> QueryResults<'a> {
             debug_assert!(ok);
 
             // TODO: is this always true? we don't get this from an async call...
-            debug_assert!(raw_details.m_eResult == sys::EResult::EResultOK);
+            debug_assert!(raw_details.m_eResult == sys::EResult::k_EResultOK);
 
             let tags = CStr::from_ptr(raw_details.m_rgchTags.as_ptr())
                 .to_string_lossy()
@@ -748,9 +749,9 @@ impl<'a> QueryResults<'a> {
                 .collect::<Vec<_>>();
 
             Some(QueryResult {
-                published_file_id: PublishedFileId(raw_details.m_nPublishedFileId.0),
-                creator_app_id: if raw_details.m_nCreatorAppID.0 != 0 { Some(AppId(raw_details.m_nCreatorAppID.0)) } else { None },
-                consumer_app_id: if raw_details.m_nConsumerAppID.0 != 0 { Some(AppId(raw_details.m_nConsumerAppID.0)) } else { None },
+                published_file_id: PublishedFileId(raw_details.m_nPublishedFileId),
+                creator_app_id: if raw_details.m_nCreatorAppID != 0 { Some(AppId(raw_details.m_nCreatorAppID)) } else { None },
+                consumer_app_id: if raw_details.m_nConsumerAppID != 0 { Some(AppId(raw_details.m_nConsumerAppID)) } else { None },
                 title: CStr::from_ptr(raw_details.m_rgchTitle.as_ptr())
                     .to_string_lossy()
                     .into_owned(),
diff --git a/src/user.rs b/src/user.rs
index 8dea06a..b5f0abf 100644
--- a/src/user.rs
+++ b/src/user.rs
@@ -12,7 +12,7 @@ impl <Manager> User<Manager> {
     /// Returns the steam id of the current user
     pub fn steam_id(&self) -> SteamId {
         unsafe {
-            SteamId(sys::SteamAPI_ISteamUser_GetSteamID(self.user).0)
+            SteamId(sys::SteamAPI_ISteamUser_GetSteamID(self.user))
         }
     }
 
@@ -61,15 +61,16 @@ impl <Manager> User<Manager> {
             let res = sys::SteamAPI_ISteamUser_BeginAuthSession(
                 self.user,
                 ticket.as_ptr() as *const _, ticket.len() as _,
-                sys::CSteamID(user.0)
+                user.0
             );
             Err(match res {
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultOK => return Ok(()),
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultInvalidTicket => AuthSessionError::InvalidTicket,
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultDuplicateRequest => AuthSessionError::DuplicateRequest,
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultInvalidVersion => AuthSessionError::InvalidVersion,
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultGameMismatch => AuthSessionError::GameMismatch,
-                sys::EBeginAuthSessionResult::EBeginAuthSessionResultExpiredTicket => AuthSessionError::ExpiredTicket,
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultOK => return Ok(()),
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultInvalidTicket => AuthSessionError::InvalidTicket,
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultDuplicateRequest => AuthSessionError::DuplicateRequest,
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultInvalidVersion => AuthSessionError::InvalidVersion,
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultGameMismatch => AuthSessionError::GameMismatch,
+                sys::EBeginAuthSessionResult::k_EBeginAuthSessionResultExpiredTicket => AuthSessionError::ExpiredTicket,
+                _ => unreachable!(),
             })
         }
     }
@@ -81,7 +82,7 @@ impl <Manager> User<Manager> {
     /// the specified entity.
     pub fn end_authentication_session(&self, user: SteamId) {
         unsafe {
-            sys::SteamAPI_ISteamUser_EndAuthSession(self.user, sys::CSteamID(user.0));
+            sys::SteamAPI_ISteamUser_EndAuthSession(self.user, user.0);
         }
     }
 }
@@ -159,7 +160,7 @@ unsafe impl Callback for AuthSessionTicketResponse {
         let val = &mut *(raw as *mut sys::GetAuthSessionTicketResponse_t);
         AuthSessionTicketResponse {
             ticket: AuthTicket(val.m_hAuthTicket),
-            result: if val.m_eResult == sys::EResult::EResultOK  {
+            result: if val.m_eResult == sys::EResult::k_EResultOK  {
                 Ok(())
             } else {
                 Err(val.m_eResult.into())
@@ -189,19 +190,20 @@ unsafe impl Callback for ValidateAuthTicketResponse {
     unsafe fn from_raw(raw: *mut libc::c_void) -> Self {
         let val = &mut *(raw as *mut sys::ValidateAuthTicketResponse_t);
         ValidateAuthTicketResponse {
-            steam_id: SteamId(val.m_SteamID.0),
-            owner_steam_id: SteamId(val.m_OwnerSteamID.0),
+            steam_id: SteamId(val.m_SteamID.m_steamid.m_unAll64Bits),
+            owner_steam_id: SteamId(val.m_OwnerSteamID.m_steamid.m_unAll64Bits),
             response: match val.m_eAuthSessionResponse {
-                sys::EAuthSessionResponse::EAuthSessionResponseOK => Ok(()),
-                sys::EAuthSessionResponse::EAuthSessionResponseUserNotConnectedToSteam => Err(AuthSessionValidateError::UserNotConnectedToSteam),
-                sys::EAuthSessionResponse::EAuthSessionResponseNoLicenseOrExpired => Err(AuthSessionValidateError::NoLicenseOrExpired),
-                sys::EAuthSessionResponse::EAuthSessionResponseVACBanned => Err(AuthSessionValidateError::VACBanned),
-                sys::EAuthSessionResponse::EAuthSessionResponseLoggedInElseWhere => Err(AuthSessionValidateError::LoggedInElseWhere),
-                sys::EAuthSessionResponse::EAuthSessionResponseVACCheckTimedOut => Err(AuthSessionValidateError::VACCheckTimedOut),
-                sys::EAuthSessionResponse::EAuthSessionResponseAuthTicketCanceled => Err(AuthSessionValidateError::AuthTicketCancelled),
-                sys::EAuthSessionResponse::EAuthSessionResponseAuthTicketInvalidAlreadyUsed => Err(AuthSessionValidateError::AuthTicketInvalidAlreadyUsed),
-                sys::EAuthSessionResponse::EAuthSessionResponseAuthTicketInvalid => Err(AuthSessionValidateError::AuthTicketInvalid),
-                sys::EAuthSessionResponse::EAuthSessionResponsePublisherIssuedBan => Err(AuthSessionValidateError::PublisherIssuedBan),
+                sys::EAuthSessionResponse::k_EAuthSessionResponseOK => Ok(()),
+                sys::EAuthSessionResponse::k_EAuthSessionResponseUserNotConnectedToSteam => Err(AuthSessionValidateError::UserNotConnectedToSteam),
+                sys::EAuthSessionResponse::k_EAuthSessionResponseNoLicenseOrExpired => Err(AuthSessionValidateError::NoLicenseOrExpired),
+                sys::EAuthSessionResponse::k_EAuthSessionResponseVACBanned => Err(AuthSessionValidateError::VACBanned),
+                sys::EAuthSessionResponse::k_EAuthSessionResponseLoggedInElseWhere => Err(AuthSessionValidateError::LoggedInElseWhere),
+                sys::EAuthSessionResponse::k_EAuthSessionResponseVACCheckTimedOut => Err(AuthSessionValidateError::VACCheckTimedOut),
+                sys::EAuthSessionResponse::k_EAuthSessionResponseAuthTicketCanceled => Err(AuthSessionValidateError::AuthTicketCancelled),
+                sys::EAuthSessionResponse::k_EAuthSessionResponseAuthTicketInvalidAlreadyUsed => Err(AuthSessionValidateError::AuthTicketInvalidAlreadyUsed),
+                sys::EAuthSessionResponse::k_EAuthSessionResponseAuthTicketInvalid => Err(AuthSessionValidateError::AuthTicketInvalid),
+                sys::EAuthSessionResponse::k_EAuthSessionResponsePublisherIssuedBan => Err(AuthSessionValidateError::PublisherIssuedBan),
+                _ => unreachable!(),
             }
         }
     }
diff --git a/src/user_stats.rs b/src/user_stats.rs
index 88f8bf6..000ffab 100644
--- a/src/user_stats.rs
+++ b/src/user_stats.rs
@@ -29,7 +29,7 @@ impl <Manager> UserStats<Manager> {
                         Err(SteamError::IOFailure)
                     } else {
                         Ok(if v.m_bLeaderboardFound != 0 {
-                            Some(Leaderboard(v.m_hSteamLeaderboard.0))
+                            Some(Leaderboard(v.m_hSteamLeaderboard))
                         } else {
                             None
                         })
@@ -45,14 +45,14 @@ impl <Manager> UserStats<Manager> {
             let name = CString::new(name).unwrap();
 
             let sort_method = match sort_method {
-                LeaderboardSortMethod::Ascending => sys::ELeaderboardSortMethod::ELeaderboardSortMethodAscending,
-                LeaderboardSortMethod::Descending => sys::ELeaderboardSortMethod::ELeaderboardSortMethodDescending,
+                LeaderboardSortMethod::Ascending => sys::ELeaderboardSortMethod::k_ELeaderboardSortMethodAscending,
+                LeaderboardSortMethod::Descending => sys::ELeaderboardSortMethod::k_ELeaderboardSortMethodDescending,
             };
 
             let display_type = match display_type {
-	            LeaderboardDisplayType::Numeric => sys::ELeaderboardDisplayType::ELeaderboardDisplayTypeNumeric,
-	            LeaderboardDisplayType::TimeSeconds => sys::ELeaderboardDisplayType::ELeaderboardDisplayTypeTimeSeconds,
-	            LeaderboardDisplayType::TimeMilliSeconds => sys::ELeaderboardDisplayType::ELeaderboardDisplayTypeTimeMilliSeconds,
+	            LeaderboardDisplayType::Numeric => sys::ELeaderboardDisplayType::k_ELeaderboardDisplayTypeNumeric,
+	            LeaderboardDisplayType::TimeSeconds => sys::ELeaderboardDisplayType::k_ELeaderboardDisplayTypeTimeSeconds,
+	            LeaderboardDisplayType::TimeMilliSeconds => sys::ELeaderboardDisplayType::k_ELeaderboardDisplayTypeTimeMilliSeconds,
             };
 
             let api_call = sys::SteamAPI_ISteamUserStats_FindOrCreateLeaderboard(self.user_stats, name.as_ptr() as *const _, sort_method, display_type);
@@ -63,7 +63,7 @@ impl <Manager> UserStats<Manager> {
                         Err(SteamError::IOFailure)
                     } else {
                         Ok(if v.m_bLeaderboardFound != 0 {
-                            Some(Leaderboard(v.m_hSteamLeaderboard.0))
+                            Some(Leaderboard(v.m_hSteamLeaderboard))
                         } else {
                             None
                         })
@@ -78,10 +78,10 @@ impl <Manager> UserStats<Manager> {
     {
         unsafe {
             let method = match method {
-                UploadScoreMethod::KeepBest => sys::ELeaderboardUploadScoreMethod::ELeaderboardUploadScoreMethodKeepBest,
-                UploadScoreMethod::ForceUpdate => sys::ELeaderboardUploadScoreMethod::ELeaderboardUploadScoreMethodForceUpdate,
+                UploadScoreMethod::KeepBest => sys::ELeaderboardUploadScoreMethod::k_ELeaderboardUploadScoreMethodKeepBest,
+                UploadScoreMethod::ForceUpdate => sys::ELeaderboardUploadScoreMethod::k_ELeaderboardUploadScoreMethodForceUpdate,
             };
-            let api_call = sys::SteamAPI_ISteamUserStats_UploadLeaderboardScore(self.user_stats, sys::SteamLeaderboard_t(leaderboard.0), method, score, details.as_ptr(), details.len() as _);
+            let api_call = sys::SteamAPI_ISteamUserStats_UploadLeaderboardScore(self.user_stats, leaderboard.0, method, score, details.as_ptr(), details.len() as _);
             register_call_result::<sys::LeaderboardScoreUploaded_t , _, _>(
                 &self.inner, api_call, CALLBACK_BASE_ID + 6,
                 move |v, io_error| {
@@ -114,11 +114,11 @@ impl <Manager> UserStats<Manager> {
     {
         unsafe {
             let request = match request {
-                LeaderboardDataRequest::Global => sys::ELeaderboardDataRequest::ELeaderboardDataRequestGlobal,
-                LeaderboardDataRequest::GlobalAroundUser => sys::ELeaderboardDataRequest::ELeaderboardDataRequestGlobalAroundUser,
-                LeaderboardDataRequest::Friends => sys::ELeaderboardDataRequest::ELeaderboardDataRequestFriends,
+                LeaderboardDataRequest::Global => sys::ELeaderboardDataRequest::k_ELeaderboardDataRequestGlobal,
+                LeaderboardDataRequest::GlobalAroundUser => sys::ELeaderboardDataRequest::k_ELeaderboardDataRequestGlobalAroundUser,
+                LeaderboardDataRequest::Friends => sys::ELeaderboardDataRequest::k_ELeaderboardDataRequestFriends,
             };
-            let api_call = sys::SteamAPI_ISteamUserStats_DownloadLeaderboardEntries(self.user_stats, sys::SteamLeaderboard_t(leaderboard.0), request, start as _, end as _);
+            let api_call = sys::SteamAPI_ISteamUserStats_DownloadLeaderboardEntries(self.user_stats, leaderboard.0, request, start as _, end as _);
             let user_stats = self.user_stats as isize;
             register_call_result::<sys::LeaderboardScoresDownloaded_t , _, _>(
                 &self.inner, api_call, CALLBACK_BASE_ID + 5,
@@ -136,7 +136,7 @@ impl <Manager> UserStats<Manager> {
                             details.set_len(entry.m_cDetails as usize);
 
                             entries.push(LeaderboardEntry {
-                                user: SteamId(entry.m_steamIDUser.0),
+                                user: SteamId(entry.m_steamIDUser.m_steamid.m_unAll64Bits),
                                 global_rank: entry.m_nGlobalRank,
                                 score: entry.m_nScore,
                                 details,
diff --git a/src/user_stats/stat_callback.rs b/src/user_stats/stat_callback.rs
index da62e6a..013cb34 100644
--- a/src/user_stats/stat_callback.rs
+++ b/src/user_stats/stat_callback.rs
@@ -28,10 +28,10 @@ unsafe impl Callback for UserStatsReceived {
     unsafe fn from_raw(raw: *mut libc::c_void) -> Self {
         let val = &mut *(raw as *mut sys::UserStatsReceived_t);
         Self {
-            steam_id: SteamId(val.m_steamIDUser.0),
+            steam_id: SteamId(val.m_steamIDUser.m_steamid.m_unAll64Bits),
             game_id: GameId(val.m_nGameID),
             result: match val.m_eResult {
-                sys::EResult::EResultOK => Ok(()),
+                sys::EResult::k_EResultOK => Ok(()),
                 err => Err(err.into()),
             },
         }
@@ -66,7 +66,7 @@ unsafe impl Callback for UserStatsStored {
         Self {
             game_id: GameId(val.m_nGameID),
             result: match val.m_eResult {
-                sys::EResult::EResultOK => Ok(()),
+                sys::EResult::k_EResultOK => Ok(()),
                 err => Err(err.into()),
             },
         }
diff --git a/src/utils.rs b/src/utils.rs
index da868c4..7f81291 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -26,7 +26,7 @@ lazy_static! {
 }
 
 /// C function to pass as the real callback, which forwards to the `WARNING_CALLBACK` if any
-unsafe extern "cdecl" fn c_warning_callback(level: i32, msg: *const c_char) {
+unsafe extern "C" fn c_warning_callback(level: i32, msg: *const c_char) {
     let lock = WARNING_CALLBACK.read().expect("warning func lock poisoned");
     let cb = match lock.as_ref() {
         Some(cb) => cb,
@@ -54,7 +54,7 @@ impl <Manager> Utils<Manager> {
     /// Returns the app ID of the current process
     pub fn app_id(&self) -> AppId {
         unsafe {
-            AppId(sys::SteamAPI_ISteamUtils_GetAppID(self.utils).0)
+            AppId(sys::SteamAPI_ISteamUtils_GetAppID(self.utils))
         }
     }
 
@@ -75,10 +75,10 @@ impl <Manager> Utils<Manager> {
     pub fn set_overlay_notification_position(&self, position: NotificationPosition) {
         unsafe {
             let position = match position {
-                NotificationPosition::TopLeft => sys::ENotificationPosition::EPositionTopLeft,
-                NotificationPosition::TopRight => sys::ENotificationPosition::EPositionTopRight,
-                NotificationPosition::BottomLeft => sys::ENotificationPosition::EPositionBottomLeft,
-                NotificationPosition::BottomRight => sys::ENotificationPosition::EPositionBottomRight,
+                NotificationPosition::TopLeft => sys::ENotificationPosition::k_EPositionTopLeft,
+                NotificationPosition::TopRight => sys::ENotificationPosition::k_EPositionTopRight,
+                NotificationPosition::BottomLeft => sys::ENotificationPosition::k_EPositionBottomLeft,
+                NotificationPosition::BottomRight => sys::ENotificationPosition::k_EPositionBottomRight,
             };
             sys::SteamAPI_ISteamUtils_SetOverlayNotificationPosition(self.utils, position);
         }
@@ -96,7 +96,7 @@ impl <Manager> Utils<Manager> {
         let mut lock = WARNING_CALLBACK.write().expect("warning func lock poisoned");
         *lock = Some(Box::new(cb));
         unsafe {
-            sys::SteamAPI_ISteamUtils_SetWarningMessageHook(self.utils, c_warning_callback);
+            sys::SteamAPI_ISteamUtils_SetWarningMessageHook(self.utils, Some(c_warning_callback));
         }
     }
 }