gns

const (
	ConfigInvalid ConfigOption = C.k_ESteamNetworkingConfig_Invalid

	// [global float, 0--100] Randomly discard N pct of packets instead of sending/recv
	// This is a global option only, since it is applied at a low level
	// where we don't have much context
	ConfigFakePacketLossSend ConfigOption = C.k_ESteamNetworkingConfig_FakePacketLoss_Send
	ConfigFakePacketLossRecv ConfigOption = C.k_ESteamNetworkingConfig_FakePacketLoss_Recv

	// [global int32].  Delay all outbound/inbound packets by N ms
	ConfigFakePacketLagSend ConfigOption = C.k_ESteamNetworkingConfig_FakePacketLag_Send
	ConfigFakePacketLagRecv ConfigOption = C.k_ESteamNetworkingConfig_FakePacketLag_Recv

	// [global float] 0-100 Percentage of packets we will add additional delay
	// to (causing them to be reordered)
	ConfigFakePacketReorderSend ConfigOption = C.k_ESteamNetworkingConfig_FakePacketReorder_Send
	ConfigFakePacketReorderRecv ConfigOption = C.k_ESteamNetworkingConfig_FakePacketReorder_Recv

	// [global int32] Extra delay, in ms, to apply to reordered packets.
	ConfigFakePacketReorderTime ConfigOption = C.k_ESteamNetworkingConfig_FakePacketReorder_Time

	// [global float 0--100] Globally duplicate some percentage of packets we send
	ConfigFakePacketDupSend ConfigOption = C.k_ESteamNetworkingConfig_FakePacketDup_Send
	ConfigFakePacketDupRecv ConfigOption = C.k_ESteamNetworkingConfig_FakePacketDup_Recv

	// [global int32] Amount of delay, in ms, to delay duplicated packets.
	// (We chose a random delay between 0 and this value)
	ConfigFakePacketDupTimeMax ConfigOption = C.k_ESteamNetworkingConfig_FakePacketDup_TimeMax

	// [connection int32] Timeout value (in ms) to use when first connecting
	ConfigTimeoutInitial ConfigOption = C.k_ESteamNetworkingConfig_TimeoutInitial

	// [connection int32] Timeout value (in ms) to use after connection is established
	ConfigTimeoutConnected ConfigOption = C.k_ESteamNetworkingConfig_TimeoutConnected

	// [connection int32] Upper limit of buffered pending bytes to be sent
	// if this is reached SendMessage will return k_EResultLimitExceeded
	// Default is 512k (524288 bytes)
	ConfigSendBufferSize ConfigOption = C.k_ESteamNetworkingConfig_SendBufferSize

	// [connection int32] Minimum/maximum send rate clamp, 0 is no limit.
	// This value will control the min/max allowed sending rate that
	// bandwidth estimation is allowed to reach.  Default is 0 (no-limit)
	ConfigSendRateMin ConfigOption = C.k_ESteamNetworkingConfig_SendRateMin
	ConfigSendRateMax ConfigOption = C.k_ESteamNetworkingConfig_SendRateMax

	// [connection int32] Nagle time, in microseconds.  When SendMessage is called, if
	// the outgoing message is less than the size of the MTU, it will be
	// queued for a delay equal to the Nagle timer value.  This is to ensure
	// that if the application sends several small messages rapidly, they are
	// coalesced into a single packet.
	// See historical RFC 896.  Value is in microseconds.
	// Default is 5000us (5ms).
	ConfigNagleTime ConfigOption = C.k_ESteamNetworkingConfig_NagleTime

	// [connection int32] Don't automatically fail IP connections that don't have
	// strong auth.  On clients, this means we will attempt the connection even if
	// we don't know our identity or can't get a cert.  On the server, it means that
	// we won't automatically reject a connection due to a failure to authenticate.
	// (You can examine the incoming connection and decide whether to accept it.)
	//
	// This is a dev configuration value, and you should not let users modify it in
	// production.
	ConfigIPAllowWithoutAuth ConfigOption = C.k_ESteamNetworkingConfig_IP_AllowWithoutAuth

	// [connection int32] Do not send UDP packets with a payload of
	// larger than N bytes.  If you set this, k_ESteamNetworkingConfig_MTU_DataSize
	// is automatically adjusted
	ConfigMTUPacketSize ConfigOption = C.k_ESteamNetworkingConfig_MTU_PacketSize

	// [connection int32] (read only) Maximum message size you can send that
	// will not fragment, based on k_ESteamNetworkingConfig_MTU_PacketSize
	ConfigMTUDataSize ConfigOption = C.k_ESteamNetworkingConfig_MTU_DataSize

	// [connection int32] Allow unencrypted (and unauthenticated) communication.
	// 0: Not allowed (the default)
	// 1: Allowed, but prefer encrypted
	// 2: Allowed, and preferred
	// 3: Required.  (Fail the connection if the peer requires encryption.)
	//
	// This is a dev configuration value, since its purpose is to disable encryption.
	// You should not let users modify it in production.  (But note that it requires
	// the peer to also modify their value in order for encryption to be disabled.)
	ConfigUnencrypted ConfigOption = C.k_ESteamNetworkingConfig_Unencrypted

	// [global int32] 0 or 1.  Some variables are "dev" variables.  They are useful
	// for debugging, but should not be adjusted in production.  When this flag is false (the default)
	// such variables will not be enumerated by the ISteamnetworkingUtils::GetFirstConfigValue
	// ISteamNetworkingUtils::GetConfigValueInfo functions.  The idea here is that you
	// can use those functions to provide a generic mechanism to set any configuration
	// value from a console or configuration file, looking up the variable by name.  Depending
	// on your game, modifying other configuration values may also have negative effects, and
	// you may wish to further lock down which variables are allowed to be modified by the user.
	// (Maybe no variables!)  Or maybe you use a whitelist or blacklist approach.
	//
	// (This flag is itself a dev variable.)
	ConfigEnumerateDevVars ConfigOption = C.k_ESteamNetworkingConfig_EnumerateDevVars

	//
	// Log levels for debuging information.  A higher priority
	// (lower numeric value) will cause more stuff to be printed.
	//
	ConfigLogLevelAckRTT        ConfigOption = C.k_ESteamNetworkingConfig_LogLevel_AckRTT        // [connection int32] RTT calculations for inline pings and replies
	ConfigLogLevelPacketDecode  ConfigOption = C.k_ESteamNetworkingConfig_LogLevel_PacketDecode  // [connection int32] log SNP packets send
	ConfigLogLevelMessage       ConfigOption = C.k_ESteamNetworkingConfig_LogLevel_Message       // [connection int32] log each message send/recv
	ConfigLogLevelPacketGaps    ConfigOption = C.k_ESteamNetworkingConfig_LogLevel_PacketGaps    // [connection int32] dropped packets
	ConfigLogLevelP2PRendezvous ConfigOption = C.k_ESteamNetworkingConfig_LogLevel_P2PRendezvous // [connection int32] P2P rendezvous messages
)

const (
	ConfigTypeInt32       ConfigType = C.k_ESteamNetworkingConfig_Int32
	ConfigTypeInt64       ConfigType = C.k_ESteamNetworkingConfig_Int64
	ConfigTypeFloat       ConfigType = C.k_ESteamNetworkingConfig_Float
	ConfigTypeString      ConfigType = C.k_ESteamNetworkingConfig_String
	ConfigTypeFunctionPtr ConfigType = C.k_ESteamNetworkingConfig_FunctionPtr // NOTE: When setting	callbacks, you should put the pointer into a variable and pass a pointer to that variable.
)

const InvalidConnection Connection = C.k_HSteamNetConnection_Invalid

const (
	// Invalid/sentinel value
	ConnectionEndInvalid ConnectionEndReason = C.k_ESteamNetConnectionEnd_Invalid

	// 1xxx: Application ended the connection in a "usual" manner.
	//       E.g.: user intentionally disconnected from the server,
	//             gameplay ended normally, etc
	ConnectionEndAppMin     ConnectionEndReason = C.k_ESteamNetConnectionEnd_App_Min
	ConnectionEndAppGeneric ConnectionEndReason = C.k_ESteamNetConnectionEnd_App_Generic
	// Use codes in this range for "normal" disconnection
	ConnectionEndAppMax ConnectionEndReason = C.k_ESteamNetConnectionEnd_App_Max

	// 2xxx: Application ended the connection in some sort of exceptional
	//       or unusual manner that might indicate a bug or configuration
	//       issue.
	//
	ConnectionEndAppExceptionMin     ConnectionEndReason = C.k_ESteamNetConnectionEnd_AppException_Min
	ConnectionEndAppExceptionGeneric ConnectionEndReason = C.k_ESteamNetConnectionEnd_AppException_Generic
	// Use codes in this range for "unusual" disconnection
	ConnectionEndAppExceptionMax ConnectionEndReason = C.k_ESteamNetConnectionEnd_AppException_Max

	// 3xxx: Connection failed or ended because of problem with the
	//       local host or their connection to the Internet.
	ConnectionEndLocalMin ConnectionEndReason = C.k_ESteamNetConnectionEnd_Local_Min

	// You cannot do what you want to do because you're running in offline mode.
	ConnectionEndLocalOfflineMode ConnectionEndReason = C.k_ESteamNetConnectionEnd_Local_OfflineMode

	// We're having trouble contacting many (perhaps all) relays.
	// Since it's unlikely that they all went offline at once, the best
	// explanation is that we have a problem on our end.  Note that we don't
	// bother distinguishing between "many" and "all", because in practice,
	// it takes time to detect a connection problem, and by the time
	// the connection has timed out, we might not have been able to
	// actively probe all of the relay clusters, even if we were able to
	// contact them at one time.  So this code just means that:
	//
	// * We don't have any recent successful communication with any relay.
	// * We have evidence of recent failures to communicate with multiple relays.
	ConnectionEndLocalManyRelayConnectivity ConnectionEndReason = C.k_ESteamNetConnectionEnd_Local_ManyRelayConnectivity

	// A hosted server is having trouble talking to the relay
	// that the client was using, so the problem is most likely
	// on our end
	ConnectionEndLocalHostedServerPrimaryRelay ConnectionEndReason = C.k_ESteamNetConnectionEnd_Local_HostedServerPrimaryRelay

	// We're not able to get the network config.  This is
	// *almost* always a local issue, since the network config
	// comes from the CDN, which is pretty darn reliable.
	ConnectionEndLocalNetworkConfig ConnectionEndReason = C.k_ESteamNetConnectionEnd_Local_NetworkConfig

	// Steam rejected our request because we don't have rights
	// to do this.
	ConnectionEndLocalRights ConnectionEndReason = C.k_ESteamNetConnectionEnd_Local_Rights

	ConnectionEndLocalMax ConnectionEndReason = C.k_ESteamNetConnectionEnd_Local_Max

	// 4xxx: Connection failed or ended, and it appears that the
	//       cause does NOT have to do with the local host or their
	//       connection to the Internet.  It could be caused by the
	//       remote host, or it could be somewhere in between.
	ConnectionEndRemoteMin ConnectionEndReason = C.k_ESteamNetConnectionEnd_Remote_Min

	// The connection was lost, and as far as we can tell our connection
	// to relevant services (relays) has not been disrupted.  This doesn't
	// mean that the problem is "their fault", it just means that it doesn't
	// appear that we are having network issues on our end.
	ConnectionEndRemoteTimeout ConnectionEndReason = C.k_ESteamNetConnectionEnd_Remote_Timeout

	// Something was invalid with the cert or crypt handshake
	// info you gave me, I don't understand or like your key types,
	// etc.
	ConnectionEndRemoteBadCrypt ConnectionEndReason = C.k_ESteamNetConnectionEnd_Remote_BadCrypt

	// You presented me with a cert that was I was able to parse
	// and *technically* we could use encrypted communication.
	// But there was a problem that prevents me from checking your identity
	// or ensuring that somebody int he middle can't observe our communication.
	// E.g.: - the CA key was missing (and I don't accept unsigned certs)
	// - The CA key isn't one that I trust,
	// - The cert doesn't was appropriately restricted by app, user, time, data center, etc.
	// - The cert wasn't issued to you.
	// - etc
	ConnectionEndRemoteBadCert ConnectionEndReason = C.k_ESteamNetConnectionEnd_Remote_BadCert

	// We couldn't rendezvous with the remote host because
	// they aren't logged into Steam
	ConnectionEndRemoteNotLoggedIn ConnectionEndReason = C.k_ESteamNetConnectionEnd_Remote_NotLoggedIn

	// We couldn't rendezvous with the remote host because
	// they aren't running the right application.
	ConnectionEndRemoteNotRunningApp ConnectionEndReason = C.k_ESteamNetConnectionEnd_Remote_NotRunningApp

	// Something wrong with the protocol version you are using.
	// (Probably the code you are running is too old.)
	ConnectionEndRemoteBadProtocolVersion ConnectionEndReason = C.k_ESteamNetConnectionEnd_Remote_BadProtocolVersion

	ConnectionEndRemoteMax ConnectionEndReason = C.k_ESteamNetConnectionEnd_Remote_Max

	// 5xxx: Connection failed for some other reason.
	ConnectionEndMiscMin ConnectionEndReason = C.k_ESteamNetConnectionEnd_Misc_Min

	// A failure that isn't necessarily the result of a software bug,
	// but that should happen rarely enough that it isn't worth specifically
	// writing UI or making a localized message for.
	// The debug string should contain further details.
	ConnectionEndMiscGeneric ConnectionEndReason = C.k_ESteamNetConnectionEnd_Misc_Generic

	// Generic failure that is most likely a software bug.
	ConnectionEndMiscInternalError ConnectionEndReason = C.k_ESteamNetConnectionEnd_Misc_InternalError

	// The connection to the remote host timed out, but we
	// don't know if the problem is on our end, in the middle,
	// or on their end.
	ConnectionEndMiscTimeout ConnectionEndReason = C.k_ESteamNetConnectionEnd_Misc_Timeout

	// We're having trouble talking to the relevant relay.
	// We don't have enough information to say whether the
	// problem is on our end or not.
	ConnectionEndMiscRelayConnectivity ConnectionEndReason = C.k_ESteamNetConnectionEnd_Misc_RelayConnectivity

	// There's some trouble talking to Steam.
	ConnectionEndMiscSteamConnectivity ConnectionEndReason = C.k_ESteamNetConnectionEnd_Misc_SteamConnectivity

	// A server in a dedicated hosting situation has no relay sessions
	// active with which to talk back to a client.  (It's the client's
	// job to open and maintain those sessions.)
	ConnectionEndMiscNoRelaySessionsToClient ConnectionEndReason = C.k_ESteamNetConnectionEnd_Misc_NoRelaySessionsToClient
	ConnectionEndMiscMax                     ConnectionEndReason = C.k_ESteamNetConnectionEnd_Misc_Max
)

const (
	// Dummy value used to indicate an error condition in the API.
	// Specified connection doesn't exist or has already been closed.
	ConnectionStateNone ConnectionState = C.k_ESteamNetworkingConnectionState_None

	// We are trying to establish whether peers can talk to each other,
	// whether they WANT to talk to each other, perform basic auth,
	// and exchange crypt keys.
	//
	// - For connections on the "client" side (initiated locally):
	//   We're in the process of trying to establish a connection.
	//   Depending on the connection type, we might not know who they are.
	//   Note that it is not possible to tell if we are waiting on the
	//   network to complete handshake packets, or for the application layer
	//   to accept the connection.
	//
	// - For connections on the "server" side (accepted through listen socket):
	//   We have completed some basic handshake and the client has presented
	//   some proof of identity.  The connection is ready to be accepted
	//   using AcceptConnection().
	//
	// In either case, any unreliable packets sent now are almost certain
	// to be dropped.  Attempts to receive packets are guaranteed to fail.
	// You may send messages if the send mode allows for them to be queued.
	// but if you close the connection before the connection is actually
	// established, any queued messages will be discarded immediately.
	// (We will not attempt to flush the queue and confirm delivery to the
	// remote host, which ordinarily happens when a connection is closed.)
	ConnectionStateConnecting ConnectionState = C.k_ESteamNetworkingConnectionState_Connecting

	// Some connection types use a back channel or trusted 3rd party
	// for earliest communication.  If the server accepts the connection,
	// then these connections switch into the rendezvous state.  During this
	// state, we still have not yet established an end-to-end route (through
	// the relay network), and so if you send any messages unreliable, they
	// are going to be discarded.
	ConnectionStateFindingRoute ConnectionState = C.k_ESteamNetworkingConnectionState_FindingRoute

	// We've received communications from our peer (and we know
	// who they are) and are all good.  If you close the connection now,
	// we will make our best effort to flush out any reliable sent data that
	// has not been acknowledged by the peer.  (But note that this happens
	// from within the application process, so unlike a TCP connection, you are
	// not totally handing it off to the operating system to deal with it.)
	ConnectionStateConnected ConnectionState = C.k_ESteamNetworkingConnectionState_Connected

	// Connection has been closed by our peer, but not closed locally.
	// The connection still exists from an API perspective.  You must close the
	// handle to free up resources.  If there are any messages in the inbound queue,
	// you may retrieve them.  Otherwise, nothing may be done with the connection
	// except to close it.
	//
	// This stats is similar to CLOSE_WAIT in the TCP state machine.
	ConnectionStateClosedByPeer ConnectionState = C.k_ESteamNetworkingConnectionState_ClosedByPeer

	// A disruption in the connection has been detected locally.  (E.g. timeout,
	// local internet connection disrupted, etc.)
	//
	// The connection still exists from an API perspective.  You must close the
	// handle to free up resources.
	//
	// Attempts to send further messages will fail.  Any remaining received messages
	// in the queue are available.
	ConnectionStateProblemDetectedLocally ConnectionState = C.k_ESteamNetworkingConnectionState_ProblemDetectedLocally
)

const (
	// Dummy/empty/invalid.
	// Plese note that if we parse a string that we don't recognize
	// but that appears reasonable, we will NOT use this type.  Instead
	// we'll use k_ESteamNetworkingIdentityType_UnknownType.
	IdentityTypeInvalid IdentityType = C.k_ESteamNetworkingIdentityType_Invalid

	//
	// Basic platform-specific identifiers.
	//
	IdentityTypeSteamID IdentityType = C.k_ESteamNetworkingIdentityType_SteamID // 64-bit CSteamID

	// Use their IP address (and port) as their "identity".
	// These types of identities are always unauthenticated.
	// They are useful for porting plain sockets code, and other
	// situations where you don't care about authentication.  In this
	// case, the local identity will be "localhost",
	// and the remote address will be their network address.
	//
	// We use the same type for either IPv4 or IPv6, and
	// the address is always store as IPv6.  We use IPv4
	// mapped addresses to handle IPv4.
	IdentityTypeIPAddress IdentityType = C.k_ESteamNetworkingIdentityType_IPAddress

	// Generic string/binary blobs.  It's up to your app to interpret this.
	// This library can tell you if the remote host presented a certificate
	// signed by somebody you have chosen to trust, with this identity on it.
	// It's up to you to ultimately decide what this identity means.
	IdentityTypeGenericString IdentityType = C.k_ESteamNetworkingIdentityType_GenericString
	IdentityTypeGenericBytes  IdentityType = C.k_ESteamNetworkingIdentityType_GenericBytes

	// This identity type is used when we parse a string that looks like is a
	// valid identity, just of a kind that we don't recognize.  In this case, we
	// can often still communicate with the peer!  Allowing such identities
	// for types we do not recognize useful is very useful for forward
	// compatibility.
	IdentityTypeUnknownType IdentityType = C.k_ESteamNetworkingIdentityType_UnknownType
)

const InvalidListenSocket ListenSocket = C.k_HSteamListenSocket_Invalid

const InvalidPollGroup PollGroup = C.k_HSteamNetPollGroup_Invalid

const (
	ResultOK                                      Result = C.k_EResultOK                    // success
	ResultFail                                    Result = C.k_EResultFail                  // generic failure
	ResultNoConnection                            Result = C.k_EResultNoConnection          // no/failed network connection
	ResultInvalidPassword                         Result = C.k_EResultInvalidPassword       // password/ticket is invalid
	ResultLoggedInElsewhere                       Result = C.k_EResultLoggedInElsewhere     // same user logged in elsewhere
	ResultInvalidProtocolVer                      Result = C.k_EResultInvalidProtocolVer    // protocol version is incorrect
	ResultInvalidParam                            Result = C.k_EResultInvalidParam          // a parameter is incorrect
	ResultFileNotFound                            Result = C.k_EResultFileNotFound          // file was not found
	ResultBusy                                    Result = C.k_EResultBusy                  // called method busy - action not taken
	ResultInvalidState                            Result = C.k_EResultInvalidState          // called object was in an invalid state
	ResultInvalidName                             Result = C.k_EResultInvalidName           // name is invalid
	ResultInvalidEmail                            Result = C.k_EResultInvalidEmail          // email is invalid
	ResultDuplicateName                           Result = C.k_EResultDuplicateName         // name is not unique
	ResultAccessDenied                            Result = C.k_EResultAccessDenied          // access is denied
	ResultTimeout                                 Result = C.k_EResultTimeout               // operation timed out
	ResultBanned                                  Result = C.k_EResultBanned                // VAC2 banned
	ResultAccountNotFound                         Result = C.k_EResultAccountNotFound       // account not found
	ResultInvalidSteamID                          Result = C.k_EResultInvalidSteamID        // steamID is invalid
	ResultServiceUnavailable                      Result = C.k_EResultServiceUnavailable    // The requested service is currently unavailable
	ResultNotLoggedOn                             Result = C.k_EResultNotLoggedOn           // The user is not logged on
	ResultPending                                 Result = C.k_EResultPending               // Request is pending (may be in process, or waiting on third party)
	ResultEncryptionFailure                       Result = C.k_EResultEncryptionFailure     // Encryption or Decryption failed
	ResultInsufficientPrivilege                   Result = C.k_EResultInsufficientPrivilege // Insufficient privilege
	ResultLimitExceeded                           Result = C.k_EResultLimitExceeded         // Too much of a good thing
	ResultRevoked                                 Result = C.k_EResultRevoked               // Access has been revoked (used for revoked guest passes)
	ResultExpired                                 Result = C.k_EResultExpired               // License/Guest pass the user is trying to access is expired
	ResultAlreadyRedeemed                         Result = C.k_EResultAlreadyRedeemed       // Guest pass has already been redeemed by account, cannot be acked again
	ResultDuplicateRequest                        Result = C.k_EResultDuplicateRequest      // The request is a duplicate and the action has already occurred in the past, ignored this time
	ResultAlreadyOwned                            Result = C.k_EResultAlreadyOwned          // All the games in this guest pass redemption request are already owned by the user
	ResultIPNotFound                              Result = C.k_EResultIPNotFound            // IP address not found
	ResultPersistFailed                           Result = C.k_EResultPersistFailed         // failed to write change to the data store
	ResultLockingFailed                           Result = C.k_EResultLockingFailed         // failed to acquire access lock for this operation
	ResultLogonSessionReplaced                    Result = C.k_EResultLogonSessionReplaced
	ResultConnectFailed                           Result = C.k_EResultConnectFailed
	ResultHandshakeFailed                         Result = C.k_EResultHandshakeFailed
	ResultIOFailure                               Result = C.k_EResultIOFailure
	ResultRemoteDisconnect                        Result = C.k_EResultRemoteDisconnect
	ResultShoppingCartNotFound                    Result = C.k_EResultShoppingCartNotFound // failed to find the shopping cart requested
	ResultBlocked                                 Result = C.k_EResultBlocked              // a user didn't allow it
	ResultIgnored                                 Result = C.k_EResultIgnored              // target is ignoring sender
	ResultNoMatch                                 Result = C.k_EResultNoMatch              // nothing matching the request found
	ResultAccountDisabled                         Result = C.k_EResultAccountDisabled
	ResultServiceReadOnly                         Result = C.k_EResultServiceReadOnly               // this service is not accepting content changes right now
	ResultAccountNotFeatured                      Result = C.k_EResultAccountNotFeatured            // account doesn't have value, so this feature isn't available
	ResultAdministratorOK                         Result = C.k_EResultAdministratorOK               // allowed to take this action, but only because requester is admin
	ResultContentVersion                          Result = C.k_EResultContentVersion                // A Version mismatch in content transmitted within the Steam protocol.
	ResultTryAnotherCM                            Result = C.k_EResultTryAnotherCM                  // The current CM can't service the user making a request, user should try another.
	ResultPasswordRequiredToKickSession           Result = C.k_EResultPasswordRequiredToKickSession // You are already logged in elsewhere, this cached credential login has failed.
	ResultAlreadyLoggedInElsewhere                Result = C.k_EResultAlreadyLoggedInElsewhere      // You are already logged in elsewhere, you must wait
	ResultSuspended                               Result = C.k_EResultSuspended                     // Long running operation (content download) suspended/paused
	ResultCancelled                               Result = C.k_EResultCancelled                     // Operation canceled (typically by user: content download)
	ResultDataCorruption                          Result = C.k_EResultDataCorruption                // Operation canceled because data is ill formed or unrecoverable
	ResultDiskFull                                Result = C.k_EResultDiskFull                      // Operation canceled - not enough disk space.
	ResultRemoteCallFailed                        Result = C.k_EResultRemoteCallFailed              // an remote call or IPC call failed
	ResultPasswordUnset                           Result = C.k_EResultPasswordUnset                 // Password could not be verified as it's unset server side
	ResultExternalAccountUnlinked                 Result = C.k_EResultExternalAccountUnlinked       // External account (PSN, Facebook...) is not linked to a Steam account
	ResultPSNTicketInvalid                        Result = C.k_EResultPSNTicketInvalid              // PSN ticket was invalid
	ResultExternalAccountAlreadyLinked            Result = C.k_EResultExternalAccountAlreadyLinked  // External account (PSN, Facebook...) is already linked to some other account, must explicitly request to replace/delete the link first
	ResultRemoteFileConflict                      Result = C.k_EResultRemoteFileConflict            // The sync cannot resume due to a conflict between the local and remote files
	ResultIllegalPassword                         Result = C.k_EResultIllegalPassword               // The requested new password is not legal
	ResultSameAsPreviousValue                     Result = C.k_EResultSameAsPreviousValue           // new value is the same as the old one ( secret question and answer )
	ResultAccountLogonDenied                      Result = C.k_EResultAccountLogonDenied            // account login denied due to 2nd factor authentication failure
	ResultCannotUseOldPassword                    Result = C.k_EResultCannotUseOldPassword          // The requested new password is not legal
	ResultInvalidLoginAuthCode                    Result = C.k_EResultInvalidLoginAuthCode          // account login denied due to auth code invalid
	ResultAccountLogonDeniedNoMail                Result = C.k_EResultAccountLogonDeniedNoMail      // account login denied due to 2nd factor auth failure - and no mail has been sent
	ResultHardwareNotCapableOfIPT                 Result = C.k_EResultHardwareNotCapableOfIPT       //
	ResultIPTInitError                            Result = C.k_EResultIPTInitError                  //
	ResultParentalControlRestricted               Result = C.k_EResultParentalControlRestricted     // operation failed due to parental control restrictions for current user
	ResultFacebookQueryError                      Result = C.k_EResultFacebookQueryError            // Facebook query returned an error
	ResultExpiredLoginAuthCode                    Result = C.k_EResultExpiredLoginAuthCode          // account login denied due to auth code expired
	ResultIPLoginRestrictionFailed                Result = C.k_EResultIPLoginRestrictionFailed
	ResultAccountLockedDown                       Result = C.k_EResultAccountLockedDown
	ResultAccountLogonDeniedVerifiedEmailRequired Result = C.k_EResultAccountLogonDeniedVerifiedEmailRequired
	ResultNoMatchingURL                           Result = C.k_EResultNoMatchingURL
	ResultBadResponse                             Result = C.k_EResultBadResponse                         // parse failure, missing field, etc.
	ResultRequirePasswordReEntry                  Result = C.k_EResultRequirePasswordReEntry              // The user cannot complete the action until they re-enter their password
	ResultValueOutOfRange                         Result = C.k_EResultValueOutOfRange                     // the value entered is outside the acceptable range
	ResultUnexpectedError                         Result = C.k_EResultUnexpectedError                     // something happened that we didn't expect to ever happen
	ResultDisabled                                Result = C.k_EResultDisabled                            // The requested service has been configured to be unavailable
	ResultInvalidCEGSubmission                    Result = C.k_EResultInvalidCEGSubmission                // The set of files submitted to the CEG server are not valid !
	ResultRestrictedDevice                        Result = C.k_EResultRestrictedDevice                    // The device being used is not allowed to perform this action
	ResultRegionLocked                            Result = C.k_EResultRegionLocked                        // The action could not be complete because it is region restricted
	ResultRateLimitExceeded                       Result = C.k_EResultRateLimitExceeded                   // Temporary rate limit exceeded, try again later, different from k_EResultLimitExceeded which may be permanent
	ResultAccountLoginDeniedNeedTwoFactor         Result = C.k_EResultAccountLoginDeniedNeedTwoFactor     // Need two-factor code to login
	ResultItemDeleted                             Result = C.k_EResultItemDeleted                         // The thing we're trying to access has been deleted
	ResultAccountLoginDeniedThrottle              Result = C.k_EResultAccountLoginDeniedThrottle          // login attempt failed, try to throttle response to possible attacker
	ResultTwoFactorCodeMismatch                   Result = C.k_EResultTwoFactorCodeMismatch               // two factor code mismatch
	ResultTwoFactorActivationCodeMismatch         Result = C.k_EResultTwoFactorActivationCodeMismatch     // activation code for two-factor didn't match
	ResultAccountAssociatedToMultiplePartners     Result = C.k_EResultAccountAssociatedToMultiplePartners // account has been associated with multiple partners
	ResultNotModified                             Result = C.k_EResultNotModified                         // data not modified
	ResultNoMobileDevice                          Result = C.k_EResultNoMobileDevice                      // the account does not have a mobile device associated with it
	ResultTimeNotSynced                           Result = C.k_EResultTimeNotSynced                       // the time presented is out of range or tolerance
	ResultSmsCodeFailed                           Result = C.k_EResultSmsCodeFailed                       // SMS code failure (no match, none pending, etc.)
	ResultAccountLimitExceeded                    Result = C.k_EResultAccountLimitExceeded                // Too many accounts access this resource
	ResultAccountActivityLimitExceeded            Result = C.k_EResultAccountActivityLimitExceeded        // Too many changes to this account
	ResultPhoneActivityLimitExceeded              Result = C.k_EResultPhoneActivityLimitExceeded          // Too many changes to this phone
	ResultRefundToWallet                          Result = C.k_EResultRefundToWallet                      // Cannot refund to payment method, must use wallet
	ResultEmailSendFailure                        Result = C.k_EResultEmailSendFailure                    // Cannot send an email
	ResultNotSettled                              Result = C.k_EResultNotSettled                          // Can't perform operation till payment has settled
	ResultNeedCaptcha                             Result = C.k_EResultNeedCaptcha                         // Needs to provide a valid captcha
	ResultGSLTDenied                              Result = C.k_EResultGSLTDenied                          // a game server login token owned by this token's owner has been banned
	ResultGSOwnerDenied                           Result = C.k_EResultGSOwnerDenied                       // game server owner is denied for other reason (account lock, community ban, vac ban, missing phone)
	ResultInvalidItemType                         Result = C.k_EResultInvalidItemType                     // the type of thing we were requested to act on is invalid
	ResultIPBanned                                Result = C.k_EResultIPBanned                            // the ip address has been banned from taking this action
	ResultGSLTExpired                             Result = C.k_EResultGSLTExpired                         // this token has expired from disuse; can be reset for use
	ResultInsufficientFunds                       Result = C.k_EResultInsufficientFunds                   // user doesn't have enough wallet funds to complete the action
	ResultTooManyPending                          Result = C.k_EResultTooManyPending                      // There are too many of this thing pending already
	ResultNoSiteLicensesFound                     Result = C.k_EResultNoSiteLicensesFound                 // No site licenses found
	ResultWGNetworkSendExceeded                   Result = C.k_EResultWGNetworkSendExceeded               // the WG couldn't send a response because we exceeded max network send size
)

const (
	// Send the message unreliably. Can be lost.  Messages *can* be larger than a
	// single MTU (UDP packet), but there is no retransmission, so if any piece
	// of the message is lost, the entire message will be dropped.
	//
	// The sending API does have some knowledge of the underlying connection, so
	// if there is no NAT-traversal accomplished or there is a recognized adjustment
	// happening on the connection, the packet will be batched until the connection
	// is open again.
	//
	// Migration note: This is not exactly the same as k_EP2PSendUnreliable!  You
	// probably want k_ESteamNetworkingSendType_UnreliableNoNagle
	SendUnreliable SendFlags = C.k_nSteamNetworkingSend_Unreliable

	// Disable Nagle's algorithm.
	// By default, Nagle's algorithm is applied to all outbound messages.  This means
	// that the message will NOT be sent immediately, in case further messages are
	// sent soon after you send this, which can be grouped together.  Any time there
	// is enough buffered data to fill a packet, the packets will be pushed out immediately,
	// but partially-full packets not be sent until the Nagle timer expires.  See
	// ISteamNetworkingSockets::FlushMessagesOnConnection, ISteamNetworkingMessages::FlushMessagesToUser
	//
	// NOTE: Don't just send every message without Nagle because you want packets to get there
	// quicker.  Make sure you understand the problem that Nagle is solving before disabling it.
	// If you are sending small messages, often many at the same time, then it is very likely that
	// it will be more efficient to leave Nagle enabled.  A typical proper use of this flag is
	// when you are sending what you know will be the last message sent for a while (e.g. the last
	// in the server simulation tick to a particular client), and you use this flag to flush all
	// messages.
	SendNoNagle SendFlags = C.k_nSteamNetworkingSend_NoNagle

	// Send a message unreliably, bypassing Nagle's algorithm for this message and any messages
	// currently pending on the Nagle timer.  This is equivalent to using k_ESteamNetworkingSend_Unreliable
	// and then immediately flushing the messages using ISteamNetworkingSockets::FlushMessagesOnConnection
	// or ISteamNetworkingMessages::FlushMessagesToUser.  (But using this flag is more efficient since you
	// only make one API call.)
	SendUnreliableNoNagle SendFlags = C.k_nSteamNetworkingSend_UnreliableNoNagle

	// If the message cannot be sent very soon (because the connection is still doing some initial
	// handshaking, route negotiations, etc), then just drop it.  This is only applicable for unreliable
	// messages.  Using this flag on reliable messages is invalid.
	SendNoDelay SendFlags = C.k_nSteamNetworkingSend_NoDelay

	// Send an unreliable message, but if it cannot be sent relatively quickly, just drop it instead of queuing it.
	// This is useful for messages that are not useful if they are excessively delayed, such as voice data.
	// NOTE: The Nagle algorithm is not used, and if the message is not dropped, any messages waiting on the
	// Nagle timer are immediately flushed.
	//
	// A message will be dropped under the following circumstances:
	// - the connection is not fully connected.  (E.g. the "Connecting" or "FindingRoute" states)
	// - there is a sufficiently large number of messages queued up already such that the current message
	//   will not be placed on the wire in the next ~200ms or so.
	//
	// If a message is dropped for these reasons, k_EResultIgnored will be returned.
	SendUnreliableNoDelay SendFlags = C.k_nSteamNetworkingSend_UnreliableNoDelay

	// Reliable message send. Can send up to k_cbMaxSteamNetworkingSocketsMessageSizeSend bytes in a single message.
	// Does fragmentation/re-assembly of messages under the hood, as well as a sliding window for
	// efficient sends of large chunks of data.
	//
	// The Nagle algorithm is used.  See notes on k_ESteamNetworkingSendType_Unreliable for more details.
	// See k_ESteamNetworkingSendType_ReliableNoNagle, ISteamNetworkingSockets::FlushMessagesOnConnection,
	// ISteamNetworkingMessages::FlushMessagesToUser
	//
	// Migration note: This is NOT the same as k_EP2PSendReliable, it's more like k_EP2PSendReliableWithBuffering
	SendReliable SendFlags = C.k_nSteamNetworkingSend_Reliable

	// Send a message reliably, but bypass Nagle's algorithm.
	//
	// Migration note: This is equivalent to k_EP2PSendReliable
	SendReliableNoNagle SendFlags = C.k_nSteamNetworkingSend_ReliableNoNagle

	// By default, message sending is queued, and the work of encryption and talking to
	// the operating system sockets, etc is done on a service thread.  This is usually a
	// a performance win when messages are sent from the "main thread".  However, if this
	// flag is set, and data is ready to be sent immediately (either from this message
	// or earlier queued data), then that work will be done in the current thread, before
	// the current call returns.  If data is not ready to be sent (due to rate limiting
	// or Nagle), then this flag has no effect.
	//
	// This is an advanced flag used to control performance at a very low level.  For
	// most applications running on modern hardware with more than one CPU core, doing
	// the work of sending on a service thread will yield the best performance.  Only
	// use this flag if you have a really good reason and understand what you are doing.
	// Otherwise you will probably just make performance worse.
	SendUseCurrentThread SendFlags = C.k_nSteamNetworkingSend_UseCurrentThread
)