Generate the bindings from the provided json file instead of bindgen (Fixes #3)

Allow us to remove the hack for accessing packed structs

11 files changed, 245 insertions, 250 deletions

diff --git a/src/app.rs b/src/app.rs
index 99f7557..882053e 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -18,7 +18,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, app_id.0) != 0
+            sys::SteamAPI_ISteamApps_BIsAppInstalled(self.apps, sys::AppId_t(app_id.0)) != 0
         }
     }
 
@@ -26,7 +26,7 @@ impl <Manager> Apps<Manager> {
     /// installed.
     pub fn is_dlc_installed(&self, app_id: AppId) -> bool {
         unsafe {
-            sys::SteamAPI_ISteamApps_BIsDlcInstalled(self.apps, app_id.0) != 0
+            sys::SteamAPI_ISteamApps_BIsDlcInstalled(self.apps, sys::AppId_t(app_id.0)) != 0
         }
     }
 
@@ -37,7 +37,7 @@ 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, app_id.0) != 0
+            sys::SteamAPI_ISteamApps_BIsSubscribedApp(self.apps, sys::AppId_t(app_id.0)) != 0
         }
     }
 
@@ -92,7 +92,7 @@ impl <Manager> Apps<Manager> {
     pub fn app_install_dir(&self, app_id: AppId) -> String {
         unsafe {
             let buffer = vec![0; 2048];
-            sys::SteamAPI_ISteamApps_GetAppInstallDir(self.apps, app_id.0, buffer.as_ptr(), buffer.len() as u32);
+            sys::SteamAPI_ISteamApps_GetAppInstallDir(self.apps, sys::AppId_t(app_id.0), buffer.as_ptr(), buffer.len() as u32);
             let path = CStr::from_ptr(buffer.as_ptr());
             path.to_string_lossy().into_owned()
         }
@@ -103,7 +103,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))
+            SteamId(sys::SteamAPI_ISteamApps_GetAppOwner(self.apps).0)
         }
     }
 
diff --git a/src/callback.rs b/src/callback.rs
index d8e186d..aec4b73 100644
--- a/src/callback.rs
+++ b/src/callback.rs
@@ -64,7 +64,7 @@ pub(crate) unsafe fn register_callback<C, F, Manager>(inner: &Arc<Inner<Manager>
         func(param);
     }
 
-    unsafe extern "C" fn run_extra<C, F>(cb: *mut c_void, userdata: *mut c_void, param: *mut c_void, _: u8, _: sys::SteamAPICall)
+    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
     {
@@ -103,12 +103,12 @@ pub(crate) unsafe fn register_callback<C, F, Manager>(inner: &Arc<Inner<Manager>
     }
 }
 
-pub(crate) unsafe fn register_call_result<C, F, Manager>(inner: &Arc<Inner<Manager>>, api_call: sys::SteamAPICall, 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, f: F)
     where F: for <'a> FnMut(&'a C, bool) + 'static + Send
 {
     struct CallData<F, Manager> {
         func: F,
-        api_call: sys::SteamAPICall,
+        api_call: sys::SteamAPICall_t,
         inner: Weak<Inner<Manager>>,
     }
 
@@ -135,7 +135,7 @@ pub(crate) unsafe fn register_call_result<C, F, Manager>(inner: &Arc<Inner<Manag
         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)
+    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>);
diff --git a/src/error.rs b/src/error.rs
index 6f3b0a9..dd5e57f 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -382,115 +382,115 @@ pub enum SteamError {
 impl From<sys::EResult> for SteamError {
     fn from(r: sys::EResult) -> Self {
         match r {
-            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,
+            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,
             _ => unreachable!(),
         }
     }
diff --git a/src/friends.rs b/src/friends.rs
index 2604fa6..b5dcdaa 100644
--- a/src/friends.rs
+++ b/src/friends.rs
@@ -70,7 +70,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 _));
+                let friend = SteamId(sys::SteamAPI_ISteamFriends_GetFriendByIndex(self.friends, idx, flags.bits() as _).0);
                 friends.push(Friend {
                     id: friend,
                     friends: self.friends,
@@ -92,7 +92,7 @@ impl <Manager> Friends<Manager> {
 
     pub fn request_user_information(&self, user: SteamId, name_only: bool) {
         unsafe {
-            sys::SteamAPI_ISteamFriends_RequestUserInformation(self.friends, user.0, name_only as u8);
+            sys::SteamAPI_ISteamFriends_RequestUserInformation(self.friends, sys::CSteamID(user.0), name_only as u8);
         }
     }
 
@@ -107,7 +107,7 @@ impl <Manager> Friends<Manager> {
     /// Opens up an invite dialog for the given lobby
     pub fn activate_invite_dialog(&self, lobby: LobbyId) {
         unsafe {
-            sys::SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialog(self.friends, lobby.0);
+            sys::SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialog(self.friends, sys::CSteamID(lobby.0));
         }
     }
 }
@@ -141,8 +141,8 @@ unsafe impl Callback for PersonaStateChange {
     unsafe fn from_raw(raw: *mut libc::c_void) -> Self {
         let val = &mut *(raw as *mut sys::PersonaStateChange_t);
         PersonaStateChange {
-            steam_id: SteamId(val.get_m_ulSteamID()),
-            flags: PersonaChange::from_bits_truncate(val.get_m_nChangeFlags() as i32),
+            steam_id: SteamId(val.m_ulSteamID),
+            flags: PersonaChange::from_bits_truncate(val.m_nChangeFlags as i32),
         }
     }
 }
@@ -160,8 +160,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.get_m_steamIDLobby()),
-            friend_steam_id: SteamId(val.get_m_steamIDFriend()),
+            lobby_steam_id: LobbyId(val.m_steamIDLobby.0),
+            friend_steam_id: SteamId(val.m_steamIDFriend.0),
         }
     }
 }
@@ -185,7 +185,7 @@ impl <Manager> Friend<Manager> {
 
     pub fn name(&self) -> String {
         unsafe {
-            let name = sys::SteamAPI_ISteamFriends_GetFriendPersonaName(self.friends, self.id.0);
+            let name = sys::SteamAPI_ISteamFriends_GetFriendPersonaName(self.friends, sys::CSteamID(self.id.0));
             let name = CStr::from_ptr(name);
             name.to_string_lossy().into_owned()
         }
@@ -193,15 +193,15 @@ impl <Manager> Friend<Manager> {
 
     pub fn state(&self) -> FriendState {
         unsafe {
-            let state = sys::SteamAPI_ISteamFriends_GetFriendPersonaState(self.friends, self.id.0);
+            let state = sys::SteamAPI_ISteamFriends_GetFriendPersonaState(self.friends, sys::CSteamID(self.id.0));
             match state {
-                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,
+                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,
                 _ => unreachable!(),
             }
         }
@@ -210,14 +210,14 @@ impl <Manager> Friend<Manager> {
     /// Returns information about the game the player is current playing if any
     pub fn game_played(&self) -> Option<FriendGame> {
         unsafe {
-            let mut info = sys::create_empty_FriendGameInfo_t();
-            if sys::SteamAPI_ISteamFriends_GetFriendGamePlayed(self.friends, self.id.0, &mut info) != 0 {
+            let mut info: sys::FriendGameInfo_t = std::mem::uninitialized();
+            if sys::SteamAPI_ISteamFriends_GetFriendGamePlayed(self.friends, sys::CSteamID(self.id.0), &mut info) != 0 {
                 Some(FriendGame {
-                    game: GameId(info.get_m_gameID()),
-                    game_address: info.get_m_unGameIP().into(),
-                    game_port: info.get_m_usGamePort(),
-                    query_port: info.get_m_usQueryPort(),
-                    lobby: LobbyId(info.get_m_steamIDLobby()),
+                    game: GameId(info.m_gameID.0),
+                    game_address: info.m_unGameIP.into(),
+                    game_port: info.m_usGamePort,
+                    query_port: info.m_usQueryPort,
+                    lobby: LobbyId(info.m_steamIDLobby.0),
                 })
             } else {
                 None
@@ -229,7 +229,7 @@ impl <Manager> Friend<Manager> {
     pub fn small_avatar(&self) -> Option<Vec<u8>> {
         unsafe {
             let utils = sys::steam_rust_get_utils();
-            let img = sys::SteamAPI_ISteamFriends_GetSmallFriendAvatar(self.friends, self.id.0);
+            let img = sys::SteamAPI_ISteamFriends_GetSmallFriendAvatar(self.friends, sys::CSteamID(self.id.0));
             if img == 0 {
                 return None;
             }
@@ -252,7 +252,7 @@ impl <Manager> Friend<Manager> {
     pub fn medium_avatar(&self) -> Option<Vec<u8>> {
         unsafe {
             let utils = sys::steam_rust_get_utils();
-            let img = sys::SteamAPI_ISteamFriends_GetMediumFriendAvatar(self.friends, self.id.0);
+            let img = sys::SteamAPI_ISteamFriends_GetMediumFriendAvatar(self.friends, sys::CSteamID(self.id.0));
             if img == 0 {
                 return None;
             }
diff --git a/src/lib.rs b/src/lib.rs
index d651f3b..50ad846 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -76,7 +76,7 @@ struct Inner<Manager> {
 
 struct Callbacks {
     callbacks: Vec<*mut libc::c_void>,
-    call_results: HashMap<sys::SteamAPICall, *mut libc::c_void>,
+    call_results: HashMap<sys::SteamAPICall_t, *mut libc::c_void>,
 }
 
 unsafe impl <Manager: Send + Sync> Send for Inner<Manager> {}
diff --git a/src/matchmaking.rs b/src/matchmaking.rs
index 0f3c17b..6788450 100644
--- a/src/matchmaking.rs
+++ b/src/matchmaking.rs
@@ -58,9 +58,9 @@ impl <Manager> Matchmaking<Manager> {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
                     } else {
-                        let mut out = Vec::with_capacity(v.get_m_nLobbiesMatching() as usize);
-                        for idx in 0 .. v.get_m_nLobbiesMatching() {
-                            out.push(LobbyId(sys::SteamAPI_ISteamMatchmaking_GetLobbyByIndex(sys::steam_rust_get_matchmaking(), idx as _)));
+                        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));
                         }
                         Ok(out)
                     })
@@ -84,10 +84,10 @@ impl <Manager> Matchmaking<Manager> {
         assert!(max_members <= 250); // Steam API limits
         unsafe {
             let ty = match ty {
-                LobbyType::Private => sys::ELobbyType_k_ELobbyTypePrivate,
-                LobbyType::FriendsOnly => sys::ELobbyType_k_ELobbyTypeFriendsOnly,
-                LobbyType::Public => sys::ELobbyType_k_ELobbyTypePublic,
-                LobbyType::Invisible => sys::ELobbyType_k_ELobbyTypeInvisible,
+                LobbyType::Private => sys::ELobbyType::ELobbyTypePrivate,
+                LobbyType::FriendsOnly => sys::ELobbyType::ELobbyTypeFriendsOnly,
+                LobbyType::Public => sys::ELobbyType::ELobbyTypePublic,
+                LobbyType::Invisible => sys::ELobbyType::ELobbyTypeInvisible,
             };
             let api_call = sys::SteamAPI_ISteamMatchmaking_CreateLobby(self.mm, ty, max_members as _);
             register_call_result::<sys::LobbyCreated_t, _, _>(
@@ -95,10 +95,10 @@ impl <Manager> Matchmaking<Manager> {
                 move |v, io_error| {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
-                    } else if v.get_m_eResult() != sys::EResult_k_EResultOK {
-                        Err(v.get_m_eResult().into())
+                    } else if v.m_eResult != sys::EResult::EResultOK {
+                        Err(v.m_eResult.into())
                     } else {
-                        Ok(LobbyId(v.get_m_ulSteamIDLobby()))
+                        Ok(LobbyId(v.m_ulSteamIDLobby))
                     })
             });
         }
@@ -109,16 +109,16 @@ impl <Manager> Matchmaking<Manager> {
         where F: FnMut(Result<LobbyId, ()>) + 'static + Send
     {
         unsafe {
-            let api_call = sys::SteamAPI_ISteamMatchmaking_JoinLobby(self.mm, lobby.0);
+            let api_call = sys::SteamAPI_ISteamMatchmaking_JoinLobby(self.mm, sys::CSteamID(lobby.0));
             register_call_result::<sys::LobbyEnter_t, _, _>(
                 &self.inner, api_call, CALLBACK_BASE_ID + 4,
                 move |v, io_error| {
                     cb(if io_error {
                         Err(())
-                    } else if v.get_m_EChatRoomEnterResponse() != 1 {
+                    } else if v.m_EChatRoomEnterResponse != 1 {
                         Err(())
                     } else {
-                        Ok(LobbyId(v.get_m_ulSteamIDLobby()))
+                        Ok(LobbyId(v.m_ulSteamIDLobby))
                     })
             });
         }
@@ -127,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, lobby.0);
+            sys::SteamAPI_ISteamMatchmaking_LeaveLobby(self.mm, sys::CSteamID(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, lobby.0))
+            SteamId(sys::SteamAPI_ISteamMatchmaking_GetLobbyOwner(self.mm, sys::CSteamID(lobby.0)).0)
         }
     }
 
@@ -143,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, lobby.0);
+            let count = sys::SteamAPI_ISteamMatchmaking_GetNumLobbyMembers(self.mm, sys::CSteamID(lobby.0));
             count as usize
         }
     }
@@ -151,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, lobby.0);
+            let count = sys::SteamAPI_ISteamMatchmaking_GetNumLobbyMembers(self.mm, sys::CSteamID(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, lobby.0, idx)
+                    sys::SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex(self.mm, sys::CSteamID(lobby.0), idx).0
                 ))
             }
             members
diff --git a/src/networking.rs b/src/networking.rs
index 258abda..032b03e 100644
--- a/src/networking.rs
+++ b/src/networking.rs
@@ -31,14 +31,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, user.0);
+            sys::SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser(self.net, sys::CSteamID(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, user.0);
+            sys::SteamAPI_ISteamNetworking_CloseP2PSessionWithUser(self.net, sys::CSteamID(user.0));
         }
     }
 
@@ -47,12 +47,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_k_EP2PSendUnreliable,
-                SendType::UnreliableNoDelay => sys::EP2PSend_k_EP2PSendUnreliableNoDelay,
-                SendType::Reliable => sys::EP2PSend_k_EP2PSendReliable,
-                SendType::ReliableWithBuffering => sys::EP2PSend_k_EP2PSendReliableWithBuffering,
+                SendType::Unreliable => sys::EP2PSend::EP2PSendUnreliable,
+                SendType::UnreliableNoDelay => sys::EP2PSend::EP2PSendUnreliableNoDelay,
+                SendType::Reliable => sys::EP2PSend::EP2PSendReliable,
+                SendType::ReliableWithBuffering => sys::EP2PSend::EP2PSendReliableWithBuffering,
             };
-            sys::SteamAPI_ISteamNetworking_SendP2PPacket(self.net, remote.0, data.as_ptr() as *const _, data.len() as u32, send_type, 0) != 0
+            sys::SteamAPI_ISteamNetworking_SendP2PPacket(self.net, sys::CSteamID(remote.0), data.as_ptr() as *const _, data.len() as u32, send_type, 0) != 0
         }
     }
 
@@ -78,9 +78,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 = 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), size as usize))
+                Some((SteamId(remote.0), size as usize))
             } else {
                 None
             }
@@ -97,13 +97,13 @@ pub struct P2PSessionRequest {
 }
 
 unsafe impl Callback for P2PSessionRequest {
-    const ID: i32 = sys::P2PSessionRequest_t_k_iCallback as i32;
+    const ID: i32 = 1202;
     const SIZE: i32 = ::std::mem::size_of::<sys::P2PSessionRequest_t>() as i32;
 
     unsafe fn from_raw(raw: *mut libc::c_void) -> Self {
         let val = &mut *(raw as *mut sys::P2PSessionRequest_t);
         P2PSessionRequest {
-            remote: SteamId(val.get_m_steamIDRemote()),
+            remote: SteamId(val.m_steamIDRemote.0),
         }
     }
 }
diff --git a/src/server.rs b/src/server.rs
index 6a01b7f..a7afbb1 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -62,9 +62,9 @@ impl Server {
             let version = CString::new(version).unwrap();
             let raw_ip: u32 = ip.into();
             let server_mode = match server_mode {
-                ServerMode::NoAuthentication => sys::EServerMode_eServerModeNoAuthentication,
-                ServerMode::Authentication => sys::EServerMode_eServerModeAuthentication,
-                ServerMode::AuthenticationAndSecure => sys::EServerMode_eServerModeAuthenticationAndSecure,
+                ServerMode::NoAuthentication => sys::EServerMode::ServerModeNoAuthentication,
+                ServerMode::Authentication => sys::EServerMode::ServerModeAuthentication,
+                ServerMode::AuthenticationAndSecure => sys::EServerMode::ServerModeAuthenticationAndSecure,
             };
             if sys::steam_rust_game_server_init(
                 raw_ip, steam_port,
@@ -109,7 +109,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))
+            SteamId(sys::SteamAPI_ISteamGameServer_GetSteamID(self.server).0)
         }
     }
 
@@ -158,16 +158,15 @@ impl Server {
             let res = sys::SteamAPI_ISteamGameServer_BeginAuthSession(
                 self.server,
                 ticket.as_ptr() as *const _, ticket.len() as _,
-                user.0
+                sys::CSteamID(user.0)
             );
             Err(match res {
-                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!(),
+                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,
             })
         }
     }
@@ -179,7 +178,7 @@ impl Server {
     /// the specified entity.
     pub fn end_authentication_session(&self, user: SteamId) {
         unsafe {
-            sys::SteamAPI_ISteamGameServer_EndAuthSession(self.server, user.0);
+            sys::SteamAPI_ISteamGameServer_EndAuthSession(self.server, sys::CSteamID(user.0));
         }
     }
 
@@ -251,7 +250,7 @@ fn test() {
 
     println!("{:?}", server.steam_id());
 
-    let _cb = server.register_callback(|v: AuthSessionTicketResponse| println!("{:?}", v));
+    let _cb = server.register_callback(|v: AuthSessionTicketResponse| println!("Got response: {:?}", v.result));
     let _cb = server.register_callback(|v: ValidateAuthTicketResponse| println!("{:?}", v));
 
     let id = server.steam_id();
diff --git a/src/user.rs b/src/user.rs
index 3263ba6..a57ae51 100644
--- a/src/user.rs
+++ b/src/user.rs
@@ -11,7 +11,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))
+            SteamId(sys::SteamAPI_ISteamUser_GetSteamID(self.user).0)
         }
     }
 
@@ -60,16 +60,15 @@ impl <Manager> User<Manager> {
             let res = sys::SteamAPI_ISteamUser_BeginAuthSession(
                 self.user,
                 ticket.as_ptr() as *const _, ticket.len() as _,
-                user.0
+                sys::CSteamID(user.0)
             );
             Err(match res {
-                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!(),
+                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,
             })
         }
     }
@@ -81,7 +80,7 @@ impl <Manager> User<Manager> {
     /// the specified entity.
     pub fn end_authentication_session(&self, user: SteamId) {
         unsafe {
-            sys::SteamAPI_ISteamUser_EndAuthSession(self.user, user.0);
+            sys::SteamAPI_ISteamUser_EndAuthSession(self.user, sys::CSteamID(user.0));
         }
     }
 }
@@ -111,7 +110,7 @@ fn test() {
     let (client, single) = Client::init().unwrap();
     let user = client.user();
 
-    let _cb = client.register_callback(|v: AuthSessionTicketResponse| println!("{:?}", v));
+    let _cb = client.register_callback(|v: AuthSessionTicketResponse| println!("Got response: {:?}", v.result));
     let _cb = client.register_callback(|v: ValidateAuthTicketResponse| println!("{:?}", v));
 
     let id = user.steam_id();
@@ -138,13 +137,11 @@ fn test() {
 
 /// A handle for an authentication ticket that can be used to cancel
 /// it.
-#[derive(Debug)]
 pub struct AuthTicket(pub(crate) sys::HAuthTicket);
 
 /// Called when generating a authentication session ticket.
 ///
 /// This can be used to verify the ticket was created successfully.
-#[derive(Debug)]
 pub struct AuthSessionTicketResponse {
     /// The ticket in question
     pub ticket: AuthTicket,
@@ -159,11 +156,11 @@ unsafe impl Callback for AuthSessionTicketResponse {
     unsafe fn from_raw(raw: *mut libc::c_void) -> Self {
         let val = &mut *(raw as *mut sys::GetAuthSessionTicketResponse_t);
         AuthSessionTicketResponse {
-            ticket: AuthTicket(val.get_m_hAuthTicket()),
-            result: if val.get_m_eResult() == sys::EResult_k_EResultOK  {
+            ticket: AuthTicket(val.m_hAuthTicket),
+            result: if val.m_eResult == sys::EResult::EResultOK  {
                 Ok(())
             } else {
-                Err(val.get_m_eResult().into())
+                Err(val.m_eResult.into())
             }
         }
     }
@@ -190,20 +187,19 @@ 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.get_m_SteamID()),
-            owner_steam_id: SteamId(val.get_m_OwnerSteamID()),
-            response: match val.get_m_eAuthSessionResponse() {
-                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!(),
+            steam_id: SteamId(val.m_SteamID.0),
+            owner_steam_id: SteamId(val.m_OwnerSteamID.0),
+            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),
             }
         }
     }
diff --git a/src/user_stats.rs b/src/user_stats.rs
index 33b92a1..745b76a 100644
--- a/src/user_stats.rs
+++ b/src/user_stats.rs
@@ -23,8 +23,8 @@ impl <Manager> UserStats<Manager> {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
                     } else {
-                        Ok(if v.get_m_bLeaderboardFound() != 0 {
-                            Some(Leaderboard(v.get_m_hSteamLeaderboard()))
+                        Ok(if v.m_bLeaderboardFound != 0 {
+                            Some(Leaderboard(v.m_hSteamLeaderboard.0))
                         } else {
                             None
                         })
@@ -40,14 +40,14 @@ impl <Manager> UserStats<Manager> {
             let name = CString::new(name).unwrap();
 
             let sort_method = match sort_method {
-                LeaderboardSortMethod::Ascending => sys::ELeaderboardSortMethod_k_ELeaderboardSortMethodAscending,
-                LeaderboardSortMethod::Descending => sys::ELeaderboardSortMethod_k_ELeaderboardSortMethodDescending,
+                LeaderboardSortMethod::Ascending => sys::ELeaderboardSortMethod::ELeaderboardSortMethodAscending,
+                LeaderboardSortMethod::Descending => sys::ELeaderboardSortMethod::ELeaderboardSortMethodDescending,
             };
 
             let display_type = match display_type {
-	            LeaderboardDisplayType::Numeric => sys::ELeaderboardDisplayType_k_ELeaderboardDisplayTypeNumeric,
-	            LeaderboardDisplayType::TimeSeconds => sys::ELeaderboardDisplayType_k_ELeaderboardDisplayTypeTimeSeconds,
-	            LeaderboardDisplayType::TimeMilliSeconds => sys::ELeaderboardDisplayType_k_ELeaderboardDisplayTypeTimeMilliSeconds,
+	            LeaderboardDisplayType::Numeric => sys::ELeaderboardDisplayType::ELeaderboardDisplayTypeNumeric,
+	            LeaderboardDisplayType::TimeSeconds => sys::ELeaderboardDisplayType::ELeaderboardDisplayTypeTimeSeconds,
+	            LeaderboardDisplayType::TimeMilliSeconds => sys::ELeaderboardDisplayType::ELeaderboardDisplayTypeTimeMilliSeconds,
             };
 
             let api_call = sys::SteamAPI_ISteamUserStats_FindOrCreateLeaderboard(self.user_stats, name.as_ptr() as *const _, sort_method, display_type);
@@ -57,8 +57,8 @@ impl <Manager> UserStats<Manager> {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
                     } else {
-                        Ok(if v.get_m_bLeaderboardFound() != 0 {
-                            Some(Leaderboard(v.get_m_hSteamLeaderboard()))
+                        Ok(if v.m_bLeaderboardFound != 0 {
+                            Some(Leaderboard(v.m_hSteamLeaderboard.0))
                         } else {
                             None
                         })
@@ -72,22 +72,22 @@ impl <Manager> UserStats<Manager> {
     {
         unsafe {
             let method = match method {
-                UploadScoreMethod::KeepBest => sys::ELeaderboardUploadScoreMethod_k_ELeaderboardUploadScoreMethodKeepBest,
-                UploadScoreMethod::ForceUpdate => sys::ELeaderboardUploadScoreMethod_k_ELeaderboardUploadScoreMethodForceUpdate,
+                UploadScoreMethod::KeepBest => sys::ELeaderboardUploadScoreMethod::ELeaderboardUploadScoreMethodKeepBest,
+                UploadScoreMethod::ForceUpdate => sys::ELeaderboardUploadScoreMethod::ELeaderboardUploadScoreMethodForceUpdate,
             };
-            let api_call = sys::SteamAPI_ISteamUserStats_UploadLeaderboardScore(self.user_stats, leaderboard.0, method, score, details.as_ptr(), details.len() as _);
+            let api_call = sys::SteamAPI_ISteamUserStats_UploadLeaderboardScore(self.user_stats, sys::SteamLeaderboard_t(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| {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
                     } else {
-                        Ok(if v.get_m_bSuccess() != 0 {
+                        Ok(if v.m_bSuccess != 0 {
                             Some(LeaderboardScoreUploaded {
-                                score: v.get_m_nScore(),
-                                was_changed: v.get_m_bScoreChanged() != 0,
-                                global_rank_new: v.get_m_nGlobalRankNew() as _,
-                                global_rank_previous: v.get_m_nGlobalRankPrevious() as _,
+                                score: v.m_nScore,
+                                was_changed: v.m_bScoreChanged != 0,
+                                global_rank_new: v.m_nGlobalRankNew as _,
+                                global_rank_previous: v.m_nGlobalRankPrevious as _,
                             })
                         } else {
                             None
@@ -108,11 +108,11 @@ impl <Manager> UserStats<Manager> {
     {
         unsafe {
             let request = match request {
-                LeaderboardDataRequest::Global => sys::ELeaderboardDataRequest_k_ELeaderboardDataRequestGlobal,
-                LeaderboardDataRequest::GlobalAroundUser => sys::ELeaderboardDataRequest_k_ELeaderboardDataRequestGlobalAroundUser,
-                LeaderboardDataRequest::Friends => sys::ELeaderboardDataRequest_k_ELeaderboardDataRequestFriends,
+                LeaderboardDataRequest::Global => sys::ELeaderboardDataRequest::ELeaderboardDataRequestGlobal,
+                LeaderboardDataRequest::GlobalAroundUser => sys::ELeaderboardDataRequest::ELeaderboardDataRequestGlobalAroundUser,
+                LeaderboardDataRequest::Friends => sys::ELeaderboardDataRequest::ELeaderboardDataRequestFriends,
             };
-            let api_call = sys::SteamAPI_ISteamUserStats_DownloadLeaderboardEntries(self.user_stats, leaderboard.0, request, start as _, end as _);
+            let api_call = sys::SteamAPI_ISteamUserStats_DownloadLeaderboardEntries(self.user_stats, sys::SteamLeaderboard_t(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,
@@ -120,19 +120,19 @@ impl <Manager> UserStats<Manager> {
                     cb(if io_error {
                         Err(SteamError::IOFailure)
                     } else {
-                        let len = v.get_m_cEntryCount();
+                        let len = v.m_cEntryCount;
                         let mut entries = Vec::with_capacity(len as usize);
                         for idx in 0 .. len {
-                            let mut entry = sys::create_empty_LeaderboardEntry_t();
+                            let mut entry: sys::LeaderboardEntry_t = std::mem::uninitialized();
                             let mut details = Vec::with_capacity(max_details_len);
 
-                            sys::SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry(user_stats as *mut _, v.get_m_hSteamLeaderboardEntries(), idx, &mut entry, details.as_mut_ptr(), max_details_len as _);
-                            details.set_len(entry.get_m_cDetails() as usize);
+                            sys::SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry(user_stats as *mut _, v.m_hSteamLeaderboardEntries, idx, &mut entry, details.as_mut_ptr(), max_details_len as _);
+                            details.set_len(entry.m_cDetails as usize);
 
                             entries.push(LeaderboardEntry {
-                                user: SteamId(entry.get_m_steamIDUser()),
-                                global_rank: entry.get_m_nGlobalRank(),
-                                score: entry.get_m_nScore(),
+                                user: SteamId(entry.m_steamIDUser.0),
+                                global_rank: entry.m_nGlobalRank,
+                                score: entry.m_nScore,
                                 details,
                             })
                         }
diff --git a/src/utils.rs b/src/utils.rs
index 43e167b..34ba6c9 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -18,7 +18,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))
+            AppId(sys::SteamAPI_ISteamUtils_GetAppID(self.utils).0)
         }
     }
 
@@ -39,10 +39,10 @@ impl <Manager> Utils<Manager> {
     pub fn set_overlay_notification_position(&self, position: NotificationPosition) {
         unsafe {
             let position = match position {
-                NotificationPosition::TopLeft => sys::ENotificationPosition_k_EPositionTopLeft,
-                NotificationPosition::TopRight => sys::ENotificationPosition_k_EPositionTopRight,
-                NotificationPosition::BottomLeft => sys::ENotificationPosition_k_EPositionBottomLeft,
-                NotificationPosition::BottomRight => sys::ENotificationPosition_k_EPositionBottomRight,
+                NotificationPosition::TopLeft => sys::ENotificationPosition::EPositionTopLeft,
+                NotificationPosition::TopRight => sys::ENotificationPosition::EPositionTopRight,
+                NotificationPosition::BottomLeft => sys::ENotificationPosition::EPositionBottomLeft,
+                NotificationPosition::BottomRight => sys::ENotificationPosition::EPositionBottomRight,
             };
             sys::SteamAPI_ISteamUtils_SetOverlayNotificationPosition(self.utils, position);
         }