VIMP Docs

English

Русский

English

Русский

Appearance

VimpNativesNetwork ​

@vimp-mp/types 2.0.1

Interface · GTA V natives API

ts
interface VimpNativesNetwork

Members ​

_networkCanTextFromGamerBeViewed ​

ts
_networkCanTextFromGamerBeViewed(): { gamerhandle: number; return: boolean }

_networkClearTunablesRegistrationContexts ​

ts
_networkClearTunablesRegistrationContexts(): void

_networkConfirmGameRestart ​

ts
_networkConfirmGameRestart(): void

_networkDoesCommunicationGroupHavePermission ​

ts
_networkDoesCommunicationGroupHavePermission(communicationtype: number): boolean

_networkDoesCommunicationGroupHaveSettingsEnabled ​

ts
_networkDoesCommunicationGroupHaveSettingsEnabled(communicationtype: number): boolean

_networkGetAccessCodeLabelBody ​

ts
_networkGetAccessCodeLabelBody(accesscode: number): string

_networkGetAccessCodeLabelHeading ​

ts
_networkGetAccessCodeLabelHeading(accesscode: number): string

_networkGetBattleyeErrorMessageLabel ​

ts
_networkGetBattleyeErrorMessageLabel(errorcode: number): string

_networkGetCommunicationGroupDefaultFlags ​

ts
_networkGetCommunicationGroupDefaultFlags(communicationtype: number): number

_networkGetCommunicationGroupFlags ​

ts
_networkGetCommunicationGroupFlags(communicationtype: number): number

_networkGetCommunicationGroupValue ​

ts
_networkGetCommunicationGroupValue(communicationtype: number): number

_networkGetGameRestartReason ​

ts
_networkGetGameRestartReason(): number

_networkGetGameRestartReasonMessageLabel ​

ts
_networkGetGameRestartReasonMessageLabel(): string

_networkGetRandomFloatRanged ​

ts
_networkGetRandomFloatRanged(rangestart: number, rangeend: number): number

_networkGetTunablesRegistrationBool ​

ts
_networkGetTunablesRegistrationBool(tunablename: number, defaultvalue: boolean): boolean

_networkGetTunablesRegistrationFloat ​

ts
_networkGetTunablesRegistrationFloat(tunablename: number, defaultvalue: number): number

_networkGetTunablesRegistrationInt ​

ts
_networkGetTunablesRegistrationInt(tunablename: number, defaultvalue: number): number

_networkHasPlayerPassedCheckType ​

ts
_networkHasPlayerPassedCheckType(checktype: number): { gamerhandle: number; return: boolean }

_networkHasRosPrivilegeMpTextCommunication ​

ts
_networkHasRosPrivilegeMpTextCommunication(): boolean

_networkHasRosPrivilegeMpVoiceCommunication ​

ts
_networkHasRosPrivilegeMpVoiceCommunication(): boolean

_networkHasRosPrivilegeReporting ​

ts
_networkHasRosPrivilegeReporting(): boolean

_networkHavePlatformCommunicationPrivileges ​

ts
_networkHavePlatformCommunicationPrivileges(): boolean

_networkHideEntityInTutorialSession ​

ts
_networkHideEntityInTutorialSession(nethandle: number, hide: boolean): void

_networkInviteClearJoinFailReason ​

ts
_networkInviteClearJoinFailReason(): void

_networkInviteGetJoinFailReason ​

ts
_networkInviteGetJoinFailReason(): string

_networkIsAmericasVersion ​

ts
_networkIsAmericasVersion(): boolean

_networkLoadGamerDisplayName ​

ts
_networkLoadGamerDisplayName(): { gamerhandle: number; return: string }

_networkMultiplayerCrossplayNotAllowed ​

ts
_networkMultiplayerCrossplayNotAllowed(): boolean

_networkSessionLeaveIncludingReason ​

ts
_networkSessionLeaveIncludingReason(leaveflags: number, leavereason: number): boolean

_networkSetCommunicationGroupFlags ​

ts
_networkSetCommunicationGroupFlags(communicationtype: number, communicationgroupflag: number): void

_networkSetTunablesRegistrationContexts ​

ts
_networkSetTunablesRegistrationContexts(): { tunablecontextdata: number }

_networkTriggerDamageEventForZeroPedDamage ​

ts
_networkTriggerDamageEventForZeroPedDamage(entity: number, trigger: boolean): void

_setFreemodeReportData ​

ts
_setFreemodeReportData(): { gamerhandle: number; reportdata: number }

activateDamageTrackerOnNetworkId ​

ts
activateDamageTrackerOnNetworkId(netid: number, toggle: boolean): void

activateDamageTrackerOnPlayer ​

ts
activateDamageTrackerOnPlayer(player: number, toggle: boolean): void

areCutsceneEntitiesNetworked ​

ts
areCutsceneEntitiesNetworked(): boolean

badSportPlayerLeftDetected ​

ts
badSportPlayerLeftDetected(event: number, amountreceived: number): { gamerhandle: number; return: boolean }

canRegisterMissionDoors ​

ts
canRegisterMissionDoors(p0: number): boolean

canRegisterMissionEntities ​

ts
canRegisterMissionEntities(pedAmt: number, vehicleAmt: number, objectAmt: number, pickupAmt: number): boolean

canRegisterMissionObjects ​

ts
canRegisterMissionObjects(amount: number): boolean

canRegisterMissionPeds ​

ts
canRegisterMissionPeds(amount: number): boolean

canRegisterMissionPickups ​

ts
canRegisterMissionPickups(amount: number): boolean

canRegisterMissionVehicles ​

ts
canRegisterMissionVehicles(amount: number): boolean

clearServiceEventArguments ​

ts
clearServiceEventArguments(): void

cloudCheckAvailability ​

ts
cloudCheckAvailability(): void

cloudDeleteMemberFile ​

ts
cloudDeleteMemberFile(p0: string): number

cloudDidRequestSucceed ​

ts
cloudDidRequestSucceed(requestid: number): boolean

cloudGetAvailabilityCheckResult ​

ts
cloudGetAvailabilityCheckResult(): boolean

cloudHasRequestCompleted ​

ts
cloudHasRequestCompleted(requestid: number): boolean

cloudIsCheckingAvailability ​

ts
cloudIsCheckingAvailability(): boolean

convertPosixTime ​

ts
convertPosixTime(posixtime: number): { timestructure: number }

delayMpStoreOpen ​

ts
delayMpStoreOpen(): void

facebookCanPostToFacebook ​

ts
facebookCanPostToFacebook(): boolean

facebookDidPostSucceed ​

ts
facebookDidPostSucceed(): boolean

facebookHasPostCompleted ​

ts
facebookHasPostCompleted(): boolean

facebookPostCompletedHeist ​

ts
facebookPostCompletedHeist(heistname: string, cashearned: number, xpearned: number): boolean

facebookPostCompletedMilestone ​

ts
facebookPostCompletedMilestone(milestoneid: number): boolean

facebookPostCreateCharacter ​

ts
facebookPostCreateCharacter(): boolean

fadeOutLocalPlayer ​

ts
fadeOutLocalPlayer(p0: boolean): void

filloutPmPlayerList ​

ts
filloutPmPlayerList(p1: number, p2: number): { gamerhandle: number; return: boolean }

filloutPmPlayerListWithNames ​

ts
filloutPmPlayerListWithNames(p2: number, p3: number): { p0: number; p1: number; return: boolean }

getCloudTimeAsInt ​

ts
getCloudTimeAsInt(): number

getCloudTimeAsString ​

ts
getCloudTimeAsString(): string

getCommerceItemCat ​

ts
getCommerceItemCat(index: number, index2: number): string

getCommerceItemId ​

ts
getCommerceItemId(index: number): string

getCommerceItemName ​

ts
getCommerceItemName(index: number): string

getCommerceItemNumCats ​

ts
getCommerceItemNumCats(index: number): number

getCommerceItemTexturename ​

ts
getCommerceItemTexturename(index: number): string

getCommerceProductPrice ​

ts
getCommerceProductPrice(index: number): string

getContentToLoadType ​

ts
getContentToLoadType(): number

getIsLaunchFromLiveArea ​

ts
getIsLaunchFromLiveArea(): boolean

getIsLiveAreaLaunchWithContent ​

ts
getIsLiveAreaLaunchWithContent(): boolean

getMaxNumNetworkObjects ​

ts
getMaxNumNetworkObjects(): number

getMaxNumNetworkPeds ​

ts
getMaxNumNetworkPeds(): number

getMaxNumNetworkPickups ​

ts
getMaxNumNetworkPickups(): number

getMaxNumNetworkVehicles ​

ts
getMaxNumNetworkVehicles(): number

getNetworkTime ​

ts
getNetworkTime(): number

getNetworkTimeAccurate ​

ts
getNetworkTimeAccurate(): number

getNumCommerceItems ​

ts
getNumCommerceItems(): number

getNumCreatedMissionObjects ​

ts
getNumCreatedMissionObjects(p0: boolean): number

getNumCreatedMissionPeds ​

ts
getNumCreatedMissionPeds(p0: boolean): number

getNumCreatedMissionVehicles ​

ts
getNumCreatedMissionVehicles(p0: boolean): number

getNumReservedMissionObjects ​

ts
getNumReservedMissionObjects(p0: boolean, p1: number): number

getNumReservedMissionPeds ​

ts
getNumReservedMissionPeds(p0: boolean, p1: number): number

getNumReservedMissionVehicles ​

ts
getNumReservedMissionVehicles(p0: boolean, p1: number): number

getOnlineVersion ​

ts
getOnlineVersion(): string

getReservedMissionEntitiesInArea ​

ts
getReservedMissionEntitiesInArea(x: number, y: number, z: number, p3: number): { out1: number; out2: number; out3: number }

getStatusOfTextureDownload ​

ts
getStatusOfTextureDownload(p0: number): number

getTimeAsString ​

ts
getTimeAsString(time: number): string

getTimeDifference ​

ts
getTimeDifference(timea: number, timeb: number): number

getTimeOffset ​

ts
getTimeOffset(timea: number, timeb: number): number

getUserPremiumAccess ​

ts
getUserPremiumAccess(): number

getUserStarterAccess ​

ts
getUserStarterAccess(): number

hasNetworkTimeStarted ​

ts
hasNetworkTimeStarted(): boolean

isCommerceDataFetchInProgress ​

ts
isCommerceDataFetchInProgress(): boolean

isCommerceDataValid ​

ts
isCommerceDataValid(): boolean

isCommerceStoreOpen ​

ts
isCommerceStoreOpen(): boolean

isDamageTrackerActiveOnNetworkId ​

ts
isDamageTrackerActiveOnNetworkId(netid: number): boolean

isDamageTrackerActiveOnPlayer ​

ts
isDamageTrackerActiveOnPlayer(player: number): boolean

isEntityAGhost ​

ts
isEntityAGhost(entity: number): boolean

isEntityInGhostCollision ​

ts
isEntityInGhostCollision(entity: number): boolean

isNetworkIdOwnedByParticipant ​

ts
isNetworkIdOwnedByParticipant(netid: number): boolean

isNetworkVehicleRunningRespotTimer ​

ts
isNetworkVehicleRunningRespotTimer(networkid: number): boolean

isPlayerInCutscene ​

ts
isPlayerInCutscene(player: number): boolean

isSphereVisibleToAnotherMachine ​

ts
isSphereVisibleToAnotherMachine(p0: number, p1: number, p2: number, p3: number): boolean

isSphereVisibleToPlayer ​

ts
isSphereVisibleToPlayer(p0: number, p1: number, p2: number, p3: number, p4: number): boolean

isStoreAvailableToUser ​

ts
isStoreAvailableToUser(): boolean

isTimeEqualTo ​

ts
isTimeEqualTo(timea: number, timeb: number): boolean

isTimeLessThan ​

ts
isTimeLessThan(timea: number, timeb: number): boolean

isTimeMoreThan ​

ts
isTimeMoreThan(timea: number, timeb: number): boolean

isUserOldEnoughToAccessStore ​

ts
isUserOldEnoughToAccessStore(): boolean

netToEnt ​

ts
netToEnt(nethandle: number): number

netToObj ​

ts
netToObj(nethandle: number): number

netToPed ​

ts
netToPed(nethandle: number): number

netToVeh ​

ts
netToVeh(nethandle: number): number

networkAcceptPresenceInvite ​

ts
networkAcceptPresenceInvite(p0: number): boolean

networkAccessTunableBool ​

ts
networkAccessTunableBool(tunablecontext: string, tunablename: string): boolean

networkAccessTunableBoolHash ​

ts
networkAccessTunableBoolHash(tunablecontext: number, tunablename: number): boolean

networkAccessTunableBoolModificationDetectionRegistrationHash ​

ts
networkAccessTunableBoolModificationDetectionRegistrationHash(contexthash: number, namehash: number): { return: boolean; value: boolean }

networkAccessTunableFloat ​

ts
networkAccessTunableFloat(tunablecontext: string, tunablename: string): { return: boolean; value: number }

networkAccessTunableFloatHash ​

ts
networkAccessTunableFloatHash(tunablecontext: number, tunablename: number): { return: boolean; value: number }

networkAccessTunableFloatModificationDetectionRegistrationHash ​

ts
networkAccessTunableFloatModificationDetectionRegistrationHash(contexthash: number, namehash: number): { return: boolean; value: number }

networkAccessTunableInt ​

ts
networkAccessTunableInt(tunablecontext: string, tunablename: string): { return: boolean; value: number }

networkAccessTunableIntHash ​

ts
networkAccessTunableIntHash(tunablecontext: number, tunablename: number): { return: boolean; value: number }

networkAccessTunableIntModificationDetectionRegistrationHash ​

ts
networkAccessTunableIntModificationDetectionRegistrationHash(contexthash: number, namehash: number): { return: boolean; value: number }

networkAccessTunableModificationDetectionClear ​

ts
networkAccessTunableModificationDetectionClear(): boolean

networkActionFollowInvite ​

ts
networkActionFollowInvite(): boolean

networkAddClientEntityAngledArea ​

ts
networkAddClientEntityAngledArea(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, radius: number): number

networkAddClientEntityArea ​

ts
networkAddClientEntityArea(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number

networkAddEntityAngledArea ​

ts
networkAddEntityAngledArea(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, width: number): number

networkAddEntityArea ​

ts
networkAddEntityArea(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number

networkAddEntityToSynchronisedScene ​

ts
networkAddEntityToSynchronisedScene(entity: number, netscene: number, animdict: string, animname: string, speed: number, speedmulitiplier: number, flag: number): void

networkAddFollowers ​

ts
networkAddFollowers(p1: number): { p0: number }

networkAddFriend ​

ts
networkAddFriend(message: string): { gamerhandle: number; return: boolean }

networkAddInvalidObjectModel ​

ts
networkAddInvalidObjectModel(modelhash: number, p1: number): void

networkAddMapEntityToSynchronisedScene ​

ts
networkAddMapEntityToSynchronisedScene(netscene: number, modelhash: number, x: number, y: number, z: number, p5: number, p6: string, p7: number, p8: number, flags: number): void

networkAddPedToSynchronisedScene ​

ts
networkAddPedToSynchronisedScene(ped: number, netscene: number, animdict: string, animnname: string, speed: number, speedmultiplier: number, duration: number, flag: number, playbackrate: number, p9: number): void

networkAddPedToSynchronisedSceneWithIk ​

ts
networkAddPedToSynchronisedSceneWithIk(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: number, p9: number): void

networkAddSynchronisedSceneCamera ​

ts
networkAddSynchronisedSceneCamera(netscene: number, animdict: string, animname: string): void

networkAllowCloningWhileInTutorial ​

ts
networkAllowCloningWhileInTutorial(p0: number, p1: number): void

networkAllowGangToJoinTutorialSession ​

ts
networkAllowGangToJoinTutorialSession(teamid: number, instanceid: number): void

networkAllowInviteProcessInPlayerSwitch ​

ts
networkAllowInviteProcessInPlayerSwitch(p0: boolean): void

networkAllowRemoteAttachmentModification ​

ts
networkAllowRemoteAttachmentModification(entity: number, toggle: boolean): void

networkAllowRemoteSyncedSceneLocalPlayerRequests ​

ts
networkAllowRemoteSyncedSceneLocalPlayerRequests(p0: number): void

networkAmIBlockedByGamer ​

ts
networkAmIBlockedByGamer(): { gamerhandle: number; return: boolean }

networkAmIBlockedByPlayer ​

ts
networkAmIBlockedByPlayer(player: number): boolean

networkAmIMutedByGamer ​

ts
networkAmIMutedByGamer(): { gamerhandle: number; return: boolean }

networkAmIMutedByPlayer ​

ts
networkAmIMutedByPlayer(player: number): boolean

networkApplyCachedPlayerHeadBlendData ​

ts
networkApplyCachedPlayerHeadBlendData(ped: number, player: number): boolean

networkApplyPedScarData ​

ts
networkApplyPedScarData(ped: number, p1: number): void

networkApplyTransitionParameter ​

ts
networkApplyTransitionParameter(p0: number, p1: number): void

networkApplyTransitionParameterString ​

ts
networkApplyTransitionParameterString(p0: number, string: string, p2: boolean): void

networkApplyVoiceProximityOverride ​

ts
networkApplyVoiceProximityOverride(x: number, y: number, z: number): void

networkAreHandlesTheSame ​

ts
networkAreHandlesTheSame(): { gamerhandle1: number; gamerhandle2: number; return: boolean }

networkArePlayersInSameTutorialSession ​

ts
networkArePlayersInSameTutorialSession(player: number, index: number): boolean

networkAreSocialClubPoliciesCurrent ​

ts
networkAreSocialClubPoliciesCurrent(): boolean

networkAreTransitionDetailsValid ​

ts
networkAreTransitionDetailsValid(p0: number): boolean

networkAttachSynchronisedSceneToEntity ​

ts
networkAttachSynchronisedSceneToEntity(netscene: number, entity: number, bone: number): void

networkBail ​

ts
networkBail(p0: number, p1: number, p2: number): void

networkBailTransition ​

ts
networkBailTransition(p0: number, p1: number, p2: number): void

networkBlockInvites ​

ts
networkBlockInvites(toggle: boolean): void

networkBlockJoinQueueInvites ​

ts
networkBlockJoinQueueInvites(toggle: boolean): void

networkBlockProxyMigrationBetweenTutorialSessions ​

ts
networkBlockProxyMigrationBetweenTutorialSessions(p0: number): void

networkCacheLocalPlayerHeadBlendData ​

ts
networkCacheLocalPlayerHeadBlendData(): void

networkCanAccessMultiplayer ​

ts
networkCanAccessMultiplayer(): { loadingstate: number; return: boolean }

networkCanBail ​

ts
networkCanBail(): boolean

networkCancelRespawnSearch ​

ts
networkCancelRespawnSearch(): void

networkCancelTransitionMatchmaking ​

ts
networkCancelTransitionMatchmaking(): void

networkCanCommunicateWithGamer ​

ts
networkCanCommunicateWithGamer(): { gamerhandle: number; return: boolean }

networkCanEnterMultiplayer ​

ts
networkCanEnterMultiplayer(): boolean

networkCanGamerPlayMultiplayerWithMe ​

ts
networkCanGamerPlayMultiplayerWithMe(): { gamerhandle: number; return: boolean }

networkCanPlayMultiplayerWithGamer ​

ts
networkCanPlayMultiplayerWithGamer(): { gamerhandle: number; return: boolean }

networkCanQueueForPreviousSessionJoin ​

ts
networkCanQueueForPreviousSessionJoin(): boolean

networkCanReceiveLocalInvite ​

ts
networkCanReceiveLocalInvite(): { gamerhandle: number; return: boolean }

networkCanSendLocalInvite ​

ts
networkCanSendLocalInvite(): { gamerhandle: number; return: boolean }

networkCanSessionEnd ​

ts
networkCanSessionEnd(): boolean

networkCanSetWaypoint ​

ts
networkCanSetWaypoint(): boolean

networkCanTextChatWithGamer ​

ts
networkCanTextChatWithGamer(): { gamerhandle: number; return: boolean }

networkCanViewGamerUserContent ​

ts
networkCanViewGamerUserContent(): { gamerhandle: number; return: boolean }

networkChangeTransitionSlots ​

ts
networkChangeTransitionSlots(p0: number, p1: boolean): void

networkCheckCanAccessAndAlert ​

ts
networkCheckCanAccessAndAlert(): boolean

networkCheckCommunicationPrivileges ​

ts
networkCheckCommunicationPrivileges(p0: number, p1: number, p2: boolean): boolean

networkCheckDataManagerForHandle ​

ts
networkCheckDataManagerForHandle(p0: number): { gamerhandle: number; return: boolean }

networkCheckDataManagerSucceededForHandle ​

ts
networkCheckDataManagerSucceededForHandle(p0: number): { gamerhandle: number; return: boolean }

networkCheckOnlinePrivileges ​

ts
networkCheckOnlinePrivileges(p0: number, p1: boolean): boolean

networkCheckPrivileges ​

ts
networkCheckPrivileges(p0: number, p1: number, p2: number): boolean

networkCheckRosLinkWentdownNotNet ​

ts
networkCheckRosLinkWentdownNotNet(): boolean

networkCheckTextCommunicationPrivileges ​

ts
networkCheckTextCommunicationPrivileges(p0: number, p1: number, p2: number): boolean

networkCheckUserContentPrivileges ​

ts
networkCheckUserContentPrivileges(p0: number, p1: number, p2: boolean): boolean

networkClanAnyDownloadMembershipPending ​

ts
networkClanAnyDownloadMembershipPending(): boolean

networkClanCrewinfoGetCrewranktitle ​

ts
networkClanCrewinfoGetCrewranktitle(p0: number, p1: string): boolean

networkClanCrewinfoGetStringValue ​

ts
networkClanCrewinfoGetStringValue(animdict: string, animname: string): boolean

networkClanDownloadMembership ​

ts
networkClanDownloadMembership(): { gamerhandle: number; return: boolean }

networkClanDownloadMembershipPending ​

ts
networkClanDownloadMembershipPending(): { p0: number; return: boolean }

networkClanGetEmblemTxdName ​

ts
networkClanGetEmblemTxdName(txdname: string): { nethandle: number; return: boolean }

networkClanGetLocalMembershipsCount ​

ts
networkClanGetLocalMembershipsCount(): number

networkClanGetMembership ​

ts
networkClanGetMembership(p2: number): { clanmembership: number; p0: number; return: boolean }

networkClanGetMembershipCount ​

ts
networkClanGetMembershipCount(): { p0: number; return: number }

networkClanGetMembershipDesc ​

ts
networkClanGetMembershipDesc(p1: number): { memberdesc: number; return: boolean }

networkClanGetMembershipValid ​

ts
networkClanGetMembershipValid(p1: number): { p0: number; return: boolean }

networkClanGetUiFormattedTag ​

ts
networkClanGetUiFormattedTag(buffersize: number, formattedtag: string): { clandesc: number }

networkClanHasCrewinfoMetadataBeenReceived ​

ts
networkClanHasCrewinfoMetadataBeenReceived(): boolean

networkClanIsEmblemReady ​

ts
networkClanIsEmblemReady(p0: number): { p1: number; return: boolean }

networkClanIsRockstarClan ​

ts
networkClanIsRockstarClan(buffersize: number): { clandesc: number; return: boolean }

networkClanJoin ​

ts
networkClanJoin(clandesc: number): boolean

networkClanPlayerGetDesc ​

ts
networkClanPlayerGetDesc(buffersize: number): { clandesc: number; gamerhandle: number; return: boolean }

networkClanPlayerIsActive ​

ts
networkClanPlayerIsActive(): { gamerhandle: number; return: boolean }

networkClanReleaseEmblem ​

ts
networkClanReleaseEmblem(p0: number): void

networkClanRemoteMembershipsAreInCache ​

ts
networkClanRemoteMembershipsAreInCache(): { p0: number; return: boolean }

networkClanRequestEmblem ​

ts
networkClanRequestEmblem(p0: number): boolean

networkClanServiceIsValid ​

ts
networkClanServiceIsValid(): boolean

networkClearClockTimeOverride ​

ts
networkClearClockTimeOverride(): void

networkClearFollowers ​

ts
networkClearFollowers(): void

networkClearFollowInvite ​

ts
networkClearFollowInvite(): boolean

networkClearFoundGamers ​

ts
networkClearFoundGamers(): void

networkClearGetGamerStatus ​

ts
networkClearGetGamerStatus(): void

networkClearGroupActivity ​

ts
networkClearGroupActivity(): void

networkClearInvalidObjectModels ​

ts
networkClearInvalidObjectModels(): void

networkClearOfflineInvitePending ​

ts
networkClearOfflineInvitePending(): void

networkClearQueuedJoinRequest ​

ts
networkClearQueuedJoinRequest(): void

networkClearTransitionCreatorHandle ​

ts
networkClearTransitionCreatorHandle(): void

networkClearVoiceChannel ​

ts
networkClearVoiceChannel(): void

networkClearVoiceProximityOverride ​

ts
networkClearVoiceProximityOverride(): void

networkCloseTransitionMatchmaking ​

ts
networkCloseTransitionMatchmaking(): void

networkConcealEntity ​

ts
networkConcealEntity(entity: number, toggle: boolean): void

networkConcealPlayer ​

ts
networkConcealPlayer(player: number, toggle: boolean, p2: boolean): void

networkCreateSynchronisedScene ​

ts
networkCreateSynchronisedScene(x: number, y: number, z: number, xrot: number, yrot: number, zrot: number, rotationorder: number, useocclusionportal: boolean, looped: boolean, p9: number, animtime: number, p11: number): number

networkDidFindGamersSucceed ​

ts
networkDidFindGamersSucceed(): boolean

networkDidGetGamerStatusSucceed ​

ts
networkDidGetGamerStatusSucceed(): boolean

networkDisableInvincibleFlashing ​

ts
networkDisableInvincibleFlashing(player: number, toggle: boolean): void

networkDisableLeaveRemotePedBehind ​

ts
networkDisableLeaveRemotePedBehind(toggle: boolean): void

networkDisableProximityMigration ​

ts
networkDisableProximityMigration(netid: number): void

networkDisableRealtimeMultiplayer ​

ts
networkDisableRealtimeMultiplayer(): void

networkDisableVoiceBandwidthRestriction ​

ts
networkDisableVoiceBandwidthRestriction(player: number): void

networkDisplaynamesFromHandlesStart ​

ts
networkDisplaynamesFromHandlesStart(p1: number): { p0: number; return: number }

networkDoesEntityExistWithNetworkId ​

ts
networkDoesEntityExistWithNetworkId(netid: number): boolean

networkDoesNetworkIdExist ​

ts
networkDoesNetworkIdExist(netid: number): boolean

networkDoesTunableExist ​

ts
networkDoesTunableExist(tunablecontext: string, tunablename: string): boolean

networkDoesTunableExistHash ​

ts
networkDoesTunableExistHash(tunablecontext: number, tunablename: number): boolean

networkDoTransitionQuickmatch ​

ts
networkDoTransitionQuickmatch(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number): boolean

networkDoTransitionQuickmatchAsync ​

ts
networkDoTransitionQuickmatchAsync(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number): boolean

networkDoTransitionQuickmatchWithGroup ​

ts
networkDoTransitionQuickmatchWithGroup(p0: number, p1: number, p2: number, p3: number, p5: number, p6: number, p7: number): { p4: number; return: boolean }

networkDoTransitionToFreemode ​

ts
networkDoTransitionToFreemode(p1: number, p2: boolean, players: number, p4: boolean): { p0: number; return: boolean }

networkDoTransitionToGame ​

ts
networkDoTransitionToGame(p0: boolean, maxplayers: number): boolean

networkDoTransitionToNewFreemode ​

ts
networkDoTransitionToNewFreemode(p1: number, players: number, p3: boolean, p4: boolean, p5: boolean): { p0: number; return: boolean }

networkDoTransitionToNewGame ​

ts
networkDoTransitionToNewGame(p0: boolean, maxplayers: number, p2: boolean): boolean

networkEnableExtraVehicleOrientationBlendChecks ​

ts
networkEnableExtraVehicleOrientationBlendChecks(netid: number, toggle: boolean): void

networkEnableVoiceBandwidthRestriction ​

ts
networkEnableVoiceBandwidthRestriction(player: number): void

networkEndTutorialSession ​

ts
networkEndTutorialSession(): void

networkEntityAreaDoesExist ​

ts
networkEntityAreaDoesExist(areahandle: number): boolean

networkEntityAreaHaveAllReplied ​

ts
networkEntityAreaHaveAllReplied(areahandle: number): boolean

networkEntityAreaIsOccupied ​

ts
networkEntityAreaIsOccupied(areahandle: number): boolean

networkEntityGetObjectId ​

ts
networkEntityGetObjectId(entity: number): number

networkEntityUseHighPrecisionRotation ​

ts
networkEntityUseHighPrecisionRotation(netid: number, toggle: boolean): void

networkExplodeHeli ​

ts
networkExplodeHeli(vehicle: number, isaudible: boolean, isinvisible: boolean, netid: number): void

networkExplodeVehicle ​

ts
networkExplodeVehicle(vehicle: number, isaudible: boolean, isinvisible: boolean, netid: number): boolean

networkFadeInEntity ​

ts
networkFadeInEntity(entity: number, state: boolean, p2: number): void

networkFadeOutEntity ​

ts
networkFadeOutEntity(entity: number, normal: boolean, slow: boolean): void

networkFindGamersInCrew ​

ts
networkFindGamersInCrew(crewid: number): boolean

networkFindLargestBunchOfPlayers ​

ts
networkFindLargestBunchOfPlayers(p0: number, p1: number): boolean

networkFindMatchedGamers ​

ts
networkFindMatchedGamers(attribute: number, fallbacklimit: number, lowerlimit: number, upperlimit: number): boolean

networkFinishBroadcastingData ​

ts
networkFinishBroadcastingData(): void

networkForceLocalPlayerScarSync ​

ts
networkForceLocalPlayerScarSync(): void

networkForceLocalUseOfSyncedSceneCamera ​

ts
networkForceLocalUseOfSyncedSceneCamera(netscene: number): void

networkGamerHasHeadset ​

ts
networkGamerHasHeadset(): { gamerhandle: number; return: boolean }

networkGamertagFromHandlePending ​

ts
networkGamertagFromHandlePending(): boolean

networkGamertagFromHandleStart ​

ts
networkGamertagFromHandleStart(): { gamerhandle: number; return: boolean }

networkGamertagFromHandleSucceeded ​

ts
networkGamertagFromHandleSucceeded(): boolean

networkGetActivityPlayerNum ​

ts
networkGetActivityPlayerNum(p0: boolean): number

networkGetAgeGroup ​

ts
networkGetAgeGroup(): number

networkGetAssistedDamageOfEntity ​

ts
networkGetAssistedDamageOfEntity(player: number, entity: number): { p2: number; return: boolean }

networkGetAssistedKillOfEntity ​

ts
networkGetAssistedKillOfEntity(player: number, entity: number): { p2: number; return: boolean }

networkGetBoneIdOfFatalHit ​

ts
networkGetBoneIdOfFatalHit(): number

networkGetContentModifierListId ​

ts
networkGetContentModifierListId(contenthash: number): number

networkGetCurrentlySelectedGamerHandleFromInviteMenu ​

ts
networkGetCurrentlySelectedGamerHandleFromInviteMenu(): { p0: number; return: boolean }

networkGetDestroyerOfEntity ​

ts
networkGetDestroyerOfEntity(entity: number): { return: number; weaponhash: number }

networkGetDestroyerOfNetworkId ​

ts
networkGetDestroyerOfNetworkId(netid: number): { return: number; weaponhash: number }

networkGetDisplaynamesFromHandles ​

ts
networkGetDisplaynamesFromHandles(p0: number, p1: number, p2: number): number

networkGetEntityFromNetworkId ​

ts
networkGetEntityFromNetworkId(netid: number): number

networkGetEntityFromObjectId ​

ts
networkGetEntityFromObjectId(p0: number): number

networkGetEntityIsLocal ​

ts
networkGetEntityIsLocal(entity: number): boolean

networkGetEntityIsNetworked ​

ts
networkGetEntityIsNetworked(entity: number): boolean

networkGetEntityKillerOfPlayer ​

ts
networkGetEntityKillerOfPlayer(player: number): { return: number; weaponhash: number }

networkGetFoundGamer ​

ts
networkGetFoundGamer(p1: number): { p0: number; return: boolean }

networkGetFriendCount ​

ts
networkGetFriendCount(): number

networkGetFriendDisplayName ​

ts
networkGetFriendDisplayName(friendindex: number): string

networkGetFriendName ​

ts
networkGetFriendName(friendindex: number): string

networkGetGameMode ​

ts
networkGetGameMode(): number

networkGetGamerStatusFromQueue ​

ts
networkGetGamerStatusFromQueue(): boolean

networkGetGamerStatusResult ​

ts
networkGetGamerStatusResult(p1: number): { p0: number; return: boolean }

networkGetGamertagFromHandle ​

ts
networkGetGamertagFromHandle(): { gamerhandle: number; return: string }

networkGetGlobalMultiplayerClock ​

ts
networkGetGlobalMultiplayerClock(): { hours: number; minutes: number; seconds: number }

networkGetHostOfScript ​

ts
networkGetHostOfScript(scriptname: string, instanceId: number, positionHash: number): number

networkGetHostOfThisScript ​

ts
networkGetHostOfThisScript(): number

networkGetHostPlayerIndex ​

ts
networkGetHostPlayerIndex(): number

networkGetInstanceIdOfThisScript ​

ts
networkGetInstanceIdOfThisScript(): number

networkGetInviteReplyStatus ​

ts
networkGetInviteReplyStatus(p0: number): number

networkGetKillerOfPlayer ​

ts
networkGetKillerOfPlayer(player: number): { return: number; weaponhash: number }

networkGetLastEntityPosReceivedOverNetwork ​

ts
networkGetLastEntityPosReceivedOverNetwork(entity: number): { x: number; y: number; z: number }

networkGetLastPlayerPosReceivedOverNetwork ​

ts
networkGetLastPlayerPosReceivedOverNetwork(player: number): { x: number; y: number; z: number }

networkGetLastVelReceivedOverNetwork ​

ts
networkGetLastVelReceivedOverNetwork(entity: number): { x: number; y: number; z: number }

networkGetLocalHandle ​

ts
networkGetLocalHandle(gamerhandlesize: number): { gamerhandle: number }

networkGetLocalSceneFromNetworkId ​

ts
networkGetLocalSceneFromNetworkId(netid: number): number

networkGetMaxFriends ​

ts
networkGetMaxFriends(): number

networkGetMaxNumParticipants ​

ts
networkGetMaxNumParticipants(): number

networkGetMuteCountForPlayer ​

ts
networkGetMuteCountForPlayer(p0: number): { p1: number; p2: number }

networkGetNetworkIdFromEntity ​

ts
networkGetNetworkIdFromEntity(entity: number): number

networkGetNpUnavailableReason ​

ts
networkGetNpUnavailableReason(): number

networkGetNumberBodyTrackerHits ​

ts
networkGetNumberBodyTrackerHits(): number

networkGetNumConnectedPlayers ​

ts
networkGetNumConnectedPlayers(): number

networkGetNumFoundGamers ​

ts
networkGetNumFoundGamers(): number

networkGetNumParticipants ​

ts
networkGetNumParticipants(): number

networkGetNumPresenceInvites ​

ts
networkGetNumPresenceInvites(): number

networkGetNumScriptParticipants ​

ts
networkGetNumScriptParticipants(scriptname: string, instanceId: number, positionHash: number): number

networkGetNumTransitionNonAsyncGamers ​

ts
networkGetNumTransitionNonAsyncGamers(): number

networkGetParticipantIndex ​

ts
networkGetParticipantIndex(index: number): number

networkGetPlatformPartyMemberCount ​

ts
networkGetPlatformPartyMemberCount(): number

networkGetPlatformPartyMembers ​

ts
networkGetPlatformPartyMembers(datasize: number): { data: number; return: number }

networkGetPlayerAccountId ​

ts
networkGetPlayerAccountId(player: number): number

networkGetPlayerFromGamerHandle ​

ts
networkGetPlayerFromGamerHandle(): { gamerhandle: number; return: number }

networkGetPlayerIndex ​

ts
networkGetPlayerIndex(player: number): number

networkGetPlayerIndexFromPed ​

ts
networkGetPlayerIndexFromPed(ped: number): number

networkGetPlayerLoudness ​

ts
networkGetPlayerLoudness(player: number): number

networkGetPlayerOwnsWaypoint ​

ts
networkGetPlayerOwnsWaypoint(player: number): boolean

networkGetPlayerTutorialSessionInstance ​

ts
networkGetPlayerTutorialSessionInstance(player: number): number

networkGetPositionHashOfThisScript ​

ts
networkGetPositionHashOfThisScript(): number

networkGetPresenceInviteContentId ​

ts
networkGetPresenceInviteContentId(p0: number): string

networkGetPresenceInviteFromAdmin ​

ts
networkGetPresenceInviteFromAdmin(p0: number): boolean

networkGetPresenceInviteHandle ​

ts
networkGetPresenceInviteHandle(p0: number): { p1: number; return: boolean }

networkGetPresenceInviteId ​

ts
networkGetPresenceInviteId(p0: number): number

networkGetPresenceInviteIndexById ​

ts
networkGetPresenceInviteIndexById(p0: number): number

networkGetPresenceInviteInviter ​

ts
networkGetPresenceInviteInviter(p0: number): string

networkGetPresenceInviteIsTournament ​

ts
networkGetPresenceInviteIsTournament(p0: number): boolean

networkGetPresenceInvitePlaylistCurrent ​

ts
networkGetPresenceInvitePlaylistCurrent(p0: number): number

networkGetPresenceInvitePlaylistLength ​

ts
networkGetPresenceInvitePlaylistLength(p0: number): number

networkGetPresenceInviteSessionId ​

ts
networkGetPresenceInviteSessionId(p0: number): number

networkGetPrimaryClanDataCancel ​

ts
networkGetPrimaryClanDataCancel(): void

networkGetPrimaryClanDataClear ​

ts
networkGetPrimaryClanDataClear(): boolean

networkGetPrimaryClanDataNew ​

ts
networkGetPrimaryClanDataNew(): { p0: number; p1: number; return: boolean }

networkGetPrimaryClanDataPending ​

ts
networkGetPrimaryClanDataPending(): boolean

networkGetPrimaryClanDataStart ​

ts
networkGetPrimaryClanDataStart(p1: number): { p0: number; return: boolean }

networkGetPrimaryClanDataSuccess ​

ts
networkGetPrimaryClanDataSuccess(): boolean

networkGetRandomInt ​

ts
networkGetRandomInt(): number

networkGetRandomIntRanged ​

ts
networkGetRandomIntRanged(rangestart: number, rangeend: number): number

networkGetRespawnResult ​

ts
networkGetRespawnResult(randomint: number): { coordinates: { x: number; y: number; z: number }; heading: number }

networkGetRespawnResultFlags ​

ts
networkGetRespawnResultFlags(p0: number): number

networkGetScriptStatus ​

ts
networkGetScriptStatus(): number

networkGetTalkerProximity ​

ts
networkGetTalkerProximity(): number

networkGetThisScriptIsNetworkScript ​

ts
networkGetThisScriptIsNetworkScript(): boolean

networkGetTimeoutTime ​

ts
networkGetTimeoutTime(): number

networkGetTotalNumPlayers ​

ts
networkGetTotalNumPlayers(): number

networkGetTransitionHost ​

ts
networkGetTransitionHost(): { gamerhandle: number; return: boolean }

networkGetTransitionMembers ​

ts
networkGetTransitionMembers(datacount: number): { data: number; return: number }

networkGetTunableCloudCrc ​

ts
networkGetTunableCloudCrc(): number

networkHandleFromFriend ​

ts
networkHandleFromFriend(friendindex: number, gamerhandlesize: number): { gamerhandle: number }

networkHandleFromMemberId ​

ts
networkHandleFromMemberId(memberid: string, gamerhandlesize: number): { gamerhandle: number }

networkHandleFromPlayer ​

ts
networkHandleFromPlayer(player: number, gamerhandlesize: number): { gamerhandle: number }

networkHandleFromUserId ​

ts
networkHandleFromUserId(userid: string, gamerhandlesize: number): { gamerhandle: number }

networkHasAgeRestrictions ​

ts
networkHasAgeRestrictions(): boolean

networkHasAutomuteOverride ​

ts
networkHasAutomuteOverride(): boolean

networkHasBoneBeenHitByKiller ​

ts
networkHasBoneBeenHitByKiller(boneindex: number): boolean

networkHasCachedPlayerHeadBlendData ​

ts
networkHasCachedPlayerHeadBlendData(player: number): boolean

networkHasConfirmedInvite ​

ts
networkHasConfirmedInvite(): boolean

networkHasControlOfDoor ​

ts
networkHasControlOfDoor(doorhash: number): boolean

networkHasControlOfEntity ​

ts
networkHasControlOfEntity(entity: number): boolean

networkHasControlOfNetworkId ​

ts
networkHasControlOfNetworkId(netid: number): boolean

networkHasControlOfPickup ​

ts
networkHasControlOfPickup(pickup: number): boolean

networkHasEntityBeenRegisteredWithThisThread ​

ts
networkHasEntityBeenRegisteredWithThisThread(entity: number): boolean

networkHasFollowInvite ​

ts
networkHasFollowInvite(): boolean

networkHasHeadset ​

ts
networkHasHeadset(): boolean

networkHashFromGamerHandle ​

ts
networkHashFromGamerHandle(): { gamerhandle: number; return: number }

networkHashFromPlayerHandle ​

ts
networkHashFromPlayerHandle(player: number): number

networkHasInvitedGamer ​

ts
networkHasInvitedGamer(): { p0: number; return: boolean }

networkHasInvitedGamerToTransition ​

ts
networkHasInvitedGamerToTransition(): { p0: number; return: boolean }

networkHasMadeInviteDecision ​

ts
networkHasMadeInviteDecision(): { gamerhandle: number; return: boolean }

networkHasPendingInvite ​

ts
networkHasPendingInvite(): boolean

networkHasPlayerStartedTransition ​

ts
networkHasPlayerStartedTransition(player: number): boolean

networkHasReceivedHostBroadcastData ​

ts
networkHasReceivedHostBroadcastData(): boolean

networkHasRosPrivilege ​

ts
networkHasRosPrivilege(index: number): boolean

networkHasRosPrivilegeEndDate ​

ts
networkHasRosPrivilegeEndDate(privilege: number): { bantype: number; return: boolean; timedata: number }

networkHasRosPrivilegePlayedLastGen ​

ts
networkHasRosPrivilegePlayedLastGen(): boolean

networkHasRosPrivilegeSpecialEditionContent ​

ts
networkHasRosPrivilegeSpecialEditionContent(): boolean

networkHasSocialClubAccount ​

ts
networkHasSocialClubAccount(): boolean

networkHasSocialNetworkingSharingPriv ​

ts
networkHasSocialNetworkingSharingPriv(): boolean

networkHasTransitionInviteBeenAcked ​

ts
networkHasTransitionInviteBeenAcked(): { p0: number; return: boolean }

networkHasValidRosCredentials ​

ts
networkHasValidRosCredentials(): boolean

networkHasViewGamerUserContentResult ​

ts
networkHasViewGamerUserContentResult(): { gamerhandle: number; return: boolean }

networkHaveCommunicationPrivileges ​

ts
networkHaveCommunicationPrivileges(p0: number, player: number): boolean

networkHaveOnlinePrivileges ​

ts
networkHaveOnlinePrivileges(): boolean

networkHavePlatformSubscription ​

ts
networkHavePlatformSubscription(): boolean

networkHaveRosBannedPriv ​

ts
networkHaveRosBannedPriv(): boolean

networkHaveRosCreateTicketPriv ​

ts
networkHaveRosCreateTicketPriv(): boolean

networkHaveRosLeaderboardWritePriv ​

ts
networkHaveRosLeaderboardWritePriv(): boolean

networkHaveRosMultiplayerPriv ​

ts
networkHaveRosMultiplayerPriv(): boolean

networkHaveRosSocialClubPriv ​

ts
networkHaveRosSocialClubPriv(): boolean

networkHaveScsPrivateMsgPriv ​

ts
networkHaveScsPrivateMsgPriv(): boolean

networkHaveUserContentPrivileges ​

ts
networkHaveUserContentPrivileges(p0: number): boolean

networkHideProjectileInCutscene ​

ts
networkHideProjectileInCutscene(): void

networkHostTransition ​

ts
networkHostTransition(p0: number, p1: number, p2: number, p3: number, p4: number, p5: boolean, p6: boolean, p7: number, p8: number, p9: number): boolean

networkIgnoreRemoteWaypoints ​

ts
networkIgnoreRemoteWaypoints(): void

networkInviteGamers ​

ts
networkInviteGamers(p1: number, p3: number): { p0: number; p2: number; return: boolean }

networkInviteGamersToTransition ​

ts
networkInviteGamersToTransition(p1: number): { p0: number; return: boolean }

networkIsActivitySession ​

ts
networkIsActivitySession(): boolean

networkIsActivitySpectator ​

ts
networkIsActivitySpectator(): boolean

networkIsActivitySpectatorFromHandle ​

ts
networkIsActivitySpectatorFromHandle(): { gamerhandle: number; return: boolean }

networkIsAddingFriend ​

ts
networkIsAddingFriend(): boolean

networkIsAnyPlayerNear ​

ts
networkIsAnyPlayerNear(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number): boolean

networkIsCableConnected ​

ts
networkIsCableConnected(): boolean

networkIsChattingInPlatformParty ​

ts
networkIsChattingInPlatformParty(): { gamerhandle: number; return: boolean }

networkIsClockTimeOverridden ​

ts
networkIsClockTimeOverridden(): boolean

networkIsCloudAvailable ​

ts
networkIsCloudAvailable(): boolean

networkIsCloudBackgroundScriptRequestPending ​

ts
networkIsCloudBackgroundScriptRequestPending(): boolean

networkIsConnetedToNpPresence ​

ts
networkIsConnetedToNpPresence(): boolean

networkIsDoorNetworked ​

ts
networkIsDoorNetworked(doorhash: number): boolean

networkIsEntityConcealed ​

ts
networkIsEntityConcealed(entity: number): boolean

networkIsEntityFading ​

ts
networkIsEntityFading(entity: number): boolean

networkIsFindingGamers ​

ts
networkIsFindingGamers(): boolean

networkIsFriend ​

ts
networkIsFriend(): { gamerhandle: number; return: boolean }

networkIsFriendHandleOnline ​

ts
networkIsFriendHandleOnline(): { gamerhandle: number; return: boolean }

networkIsFriendIndexOnline ​

ts
networkIsFriendIndexOnline(friendindex: number): boolean

networkIsFriendInMultiplayer ​

ts
networkIsFriendInMultiplayer(friendname: string): boolean

networkIsFriendInSameTitle ​

ts
networkIsFriendInSameTitle(friendname: string): boolean

networkIsFriendOnline ​

ts
networkIsFriendOnline(name: string): boolean

networkIsGameInProgress ​

ts
networkIsGameInProgress(): boolean

networkIsGamerBlockedByMe ​

ts
networkIsGamerBlockedByMe(): { gamerhandle: number; return: boolean }

networkIsGamerInMySession ​

ts
networkIsGamerInMySession(): { gamerhandle: number; return: boolean }

networkIsGamerMutedByMe ​

ts
networkIsGamerMutedByMe(): { gamerhandle: number; return: boolean }

networkIsGamerTalking ​

ts
networkIsGamerTalking(): { gamerhandle: number; return: boolean }

networkIsGettingGamerStatus ​

ts
networkIsGettingGamerStatus(): boolean

networkIsHandleValid ​

ts
networkIsHandleValid(gamerhandlesize: number): { gamerhandle: number; return: boolean }

networkIsHost ​

ts
networkIsHost(): boolean

networkIsHostOfThisScript ​

ts
networkIsHostOfThisScript(): boolean

networkIsInactiveProfile ​

ts
networkIsInactiveProfile(): { p0: number; return: boolean }

networkIsInMpCutscene ​

ts
networkIsInMpCutscene(): boolean

networkIsInPlatformParty ​

ts
networkIsInPlatformParty(): boolean

networkIsInPlatformPartyChat ​

ts
networkIsInPlatformPartyChat(): boolean

networkIsInSession ​

ts
networkIsInSession(): boolean

networkIsInSpectatorMode ​

ts
networkIsInSpectatorMode(): boolean

networkIsInTransition ​

ts
networkIsInTransition(): boolean

networkIsInTutorialSession ​

ts
networkIsInTutorialSession(): boolean

networkIsLocalPlayerInvincible ​

ts
networkIsLocalPlayerInvincible(): boolean

networkIsLoggedInToPsn ​

ts
networkIsLoggedInToPsn(): boolean

networkIsMultiplayerDisabled ​

ts
networkIsMultiplayerDisabled(): boolean

networkIsNetworkIdRemotelyControlled ​

ts
networkIsNetworkIdRemotelyControlled(netid: number): boolean

networkIsNpAvailable ​

ts
networkIsNpAvailable(): boolean

networkIsNpPending ​

ts
networkIsNpPending(): boolean

networkIsOfflineInvitePending ​

ts
networkIsOfflineInvitePending(): boolean

networkIsParticipantActive ​

ts
networkIsParticipantActive(p0: number): boolean

networkIsPendingFriend ​

ts
networkIsPendingFriend(p0: number): boolean

networkIsPlatformSubscriptionCheckPending ​

ts
networkIsPlatformSubscriptionCheckPending(): boolean

networkIsPlayerActive ​

ts
networkIsPlayerActive(player: number): boolean

networkIsPlayerAParticipant ​

ts
networkIsPlayerAParticipant(player: number): boolean

networkIsPlayerAParticipantOnScript ​

ts
networkIsPlayerAParticipantOnScript(player: number, script: string, instanceId: number): boolean

networkIsPlayerBlockedByMe ​

ts
networkIsPlayerBlockedByMe(player: number): boolean

networkIsPlayerConcealed ​

ts
networkIsPlayerConcealed(player: number): boolean

networkIsPlayerConnected ​

ts
networkIsPlayerConnected(player: number): boolean

networkIsPlayerFading ​

ts
networkIsPlayerFading(player: number): boolean

networkIsPlayerInMpCutscene ​

ts
networkIsPlayerInMpCutscene(player: number): boolean

networkIsPlayerMutedByMe ​

ts
networkIsPlayerMutedByMe(player: number): boolean

networkIsPlayerOnBlocklist ​

ts
networkIsPlayerOnBlocklist(): { gamerhandle: number; return: boolean }

networkIsPlayerTalking ​

ts
networkIsPlayerTalking(player: number): boolean

networkIsPrivilegeCheckInProgress ​

ts
networkIsPrivilegeCheckInProgress(): boolean

networkIsPushToTalkActive ​

ts
networkIsPushToTalkActive(): boolean

networkIsQueuingForSessionJoin ​

ts
networkIsQueuingForSessionJoin(): boolean

networkIsRefreshingRosCredentials ​

ts
networkIsRefreshingRosCredentials(): boolean

networkIsScriptActive ​

ts
networkIsScriptActive(scriptname: string, instanceId: number, p2: boolean, positionHash: number): boolean

networkIsScriptActiveByHash ​

ts
networkIsScriptActiveByHash(scripthash: number, p1: number, p2: boolean, p3: number): boolean

networkIsSessionActive ​

ts
networkIsSessionActive(): boolean

networkIsSessionBusy ​

ts
networkIsSessionBusy(): boolean

networkIsSessionStarted ​

ts
networkIsSessionStarted(): boolean

networkIsShowingSystemUiOrRecentlyRequestedUpsell ​

ts
networkIsShowingSystemUiOrRecentlyRequestedUpsell(): boolean

networkIsSignedIn ​

ts
networkIsSignedIn(): boolean

networkIsSignedOnline ​

ts
networkIsSignedOnline(): boolean

networkIsThreadANetworkScript ​

ts
networkIsThreadANetworkScript(threadid: number): boolean

networkIsTitleUpdateRequired ​

ts
networkIsTitleUpdateRequired(): boolean

networkIsTransitionBusy ​

ts
networkIsTransitionBusy(): boolean

networkIsTransitionClosedCrew ​

ts
networkIsTransitionClosedCrew(): boolean

networkIsTransitionClosedFriends ​

ts
networkIsTransitionClosedFriends(): boolean

networkIsTransitionHost ​

ts
networkIsTransitionHost(): boolean

networkIsTransitionHostFromHandle ​

ts
networkIsTransitionHostFromHandle(): { gamerhandle: number; return: boolean }

networkIsTransitionLeavePostponed ​

ts
networkIsTransitionLeavePostponed(): boolean

networkIsTransitionMatchmaking ​

ts
networkIsTransitionMatchmaking(): boolean

networkIsTransitionOpenToMatchmaking ​

ts
networkIsTransitionOpenToMatchmaking(): boolean

networkIsTransitionPrivate ​

ts
networkIsTransitionPrivate(): boolean

networkIsTransitionSolo ​

ts
networkIsTransitionSolo(): boolean

networkIsTransitionStarted ​

ts
networkIsTransitionStarted(): boolean

networkIsTransitionToGame ​

ts
networkIsTransitionToGame(): boolean

networkIsTransitionVisibilityLocked ​

ts
networkIsTransitionVisibilityLocked(): boolean

networkIsTunableCloudRequestPending ​

ts
networkIsTunableCloudRequestPending(): boolean

networkIsTutorialSessionChangePending ​

ts
networkIsTutorialSessionChangePending(): boolean

networkIsUsingOnlinePromotion ​

ts
networkIsUsingOnlinePromotion(): boolean

networkJoinGroupActivity ​

ts
networkJoinGroupActivity(): boolean

networkJoinPreviouslyFailedSession ​

ts
networkJoinPreviouslyFailedSession(): boolean

networkJoinPreviouslyFailedTransition ​

ts
networkJoinPreviouslyFailedTransition(): boolean

networkJoinTransition ​

ts
networkJoinTransition(player: number): boolean

networkKeepEntityCollisionDisabledAfterAnimScene ​

ts
networkKeepEntityCollisionDisabledAfterAnimScene(p0: number, p1: number): void

networkLaunchTransition ​

ts
networkLaunchTransition(): boolean

networkLeavePedBehindBeforeCutscene ​

ts
networkLeavePedBehindBeforeCutscene(player: number, p1: boolean): void

networkLeavePedBehindBeforeWarp ​

ts
networkLeavePedBehindBeforeWarp(player: number, x: number, y: number, z: number, p4: boolean, p5: boolean): void

networkLeaveTransition ​

ts
networkLeaveTransition(): boolean

networkMarkAsPreferredActivity ​

ts
networkMarkAsPreferredActivity(p0: boolean): void

networkMarkAsWaitingAsync ​

ts
networkMarkAsWaitingAsync(p0: boolean): void

networkMarkTransitionGamerAsFullyJoined ​

ts
networkMarkTransitionGamerAsFullyJoined(): { p0: number; return: boolean }

networkMemberIdFromGamerHandle ​

ts
networkMemberIdFromGamerHandle(): { gamerhandle: number; return: string }

networkNeedToStartNewGameButBlocked ​

ts
networkNeedToStartNewGameButBlocked(): boolean

networkOnReturnToSinglePlayer ​

ts
networkOnReturnToSinglePlayer(): void

networkOpenTransitionMatchmaking ​

ts
networkOpenTransitionMatchmaking(): void

networkOverrideChatRestrictions ​

ts
networkOverrideChatRestrictions(player: number, toggle: boolean): void

networkOverrideClockRate ​

ts
networkOverrideClockRate(ms: number): void

networkOverrideClockTime ​

ts
networkOverrideClockTime(hours: number, minutes: number, seconds: number): void

networkOverrideCoordsAndHeading ​

ts
networkOverrideCoordsAndHeading(entity: number, x: number, y: number, z: number, heading: number): void

networkOverrideReceiveRestrictions ​

ts
networkOverrideReceiveRestrictions(player: number, toggle: boolean): void

networkOverrideReceiveRestrictionsAll ​

ts
networkOverrideReceiveRestrictionsAll(toggle: boolean): void

networkOverrideSendRestrictions ​

ts
networkOverrideSendRestrictions(player: number, toggle: boolean): void

networkOverrideSendRestrictionsAll ​

ts
networkOverrideSendRestrictionsAll(toggle: boolean): void

networkOverrideTeamRestrictions ​

ts
networkOverrideTeamRestrictions(team: number, toggle: boolean): void

networkOverrideTransitionChat ​

ts
networkOverrideTransitionChat(p0: boolean): void

networkPatchPostCutsceneHs4fTunEnt ​

ts
networkPatchPostCutsceneHs4fTunEnt(ped: number): void

networkPermissionsHasGamerRecord ​

ts
networkPermissionsHasGamerRecord(): { gamerhandle: number; return: boolean }

networkPlayerGetCheaterReason ​

ts
networkPlayerGetCheaterReason(): number

networkPlayerGetName ​

ts
networkPlayerGetName(player: number): string

networkPlayerGetUserid ​

ts
networkPlayerGetUserid(player: number): { return: string; userid: number }

networkPlayerHasHeadset ​

ts
networkPlayerHasHeadset(player: number): boolean

networkPlayerIndexIsCheater ​

ts
networkPlayerIndexIsCheater(player: number): boolean

networkPlayerIsBadsport ​

ts
networkPlayerIsBadsport(): boolean

networkPlayerIsCheater ​

ts
networkPlayerIsCheater(): boolean

networkPlayerIsRockstarDev ​

ts
networkPlayerIsRockstarDev(player: number): boolean

networkPreventScriptHostMigration ​

ts
networkPreventScriptHostMigration(): void

networkQueryRespawnResults ​

ts
networkQueryRespawnResults(): { p0: number; return: number }

networkQueueGamerForStatus ​

ts
networkQueueGamerForStatus(): { p0: number; return: boolean }

networkQuitMpToDesktop ​

ts
networkQuitMpToDesktop(): void

networkRegisterEntityAsNetworked ​

ts
networkRegisterEntityAsNetworked(entity: number): void

networkRegisterHighFrequencyHostBroadcastVariables ​

ts
networkRegisterHighFrequencyHostBroadcastVariables(p0: number, p1: number, p2: number): void

networkRegisterHighFrequencyPlayerBroadcastVariables ​

ts
networkRegisterHighFrequencyPlayerBroadcastVariables(p0: number, p1: number, p2: number): void

networkRegisterHostBroadcastVariables ​

ts
networkRegisterHostBroadcastVariables(numvars: number, debugname: string): { vars: number }

networkRegisterPlayerBroadcastVariables ​

ts
networkRegisterPlayerBroadcastVariables(numvars: number, debugname: string): { vars: number }

networkRemainInGameChat ​

ts
networkRemainInGameChat(p0: boolean): void

networkRemoveAllQueuedJoinRequests ​

ts
networkRemoveAllQueuedJoinRequests(): void

networkRemoveAllTransitionInvite ​

ts
networkRemoveAllTransitionInvite(): void

networkRemoveAndCancelAllInvites ​

ts
networkRemoveAndCancelAllInvites(): void

networkRemoveAndCancelAllTransitionInvites ​

ts
networkRemoveAndCancelAllTransitionInvites(): void

networkRemoveEntityArea ​

ts
networkRemoveEntityArea(areahandle: number): boolean

networkRemovePresenceInvite ​

ts
networkRemovePresenceInvite(p0: number): boolean

networkRemoveTransitionInvite ​

ts
networkRemoveTransitionInvite(): { p0: number }

networkRequestCloudBackgroundScripts ​

ts
networkRequestCloudBackgroundScripts(): boolean

networkRequestCloudTunables ​

ts
networkRequestCloudTunables(): void

networkRequestControlOfDoor ​

ts
networkRequestControlOfDoor(doorid: number): boolean

networkRequestControlOfEntity ​

ts
networkRequestControlOfEntity(entity: number): boolean

networkRequestControlOfNetworkId ​

ts
networkRequestControlOfNetworkId(netid: number): boolean

networkRequestInviteConfirmedEvent ​

ts
networkRequestInviteConfirmedEvent(): boolean

networkRequestToBeHostOfThisScript ​

ts
networkRequestToBeHostOfThisScript(): void

networkResetBodyTracker ​

ts
networkResetBodyTracker(): void

networkResolvePrivilegeUserContent ​

ts
networkResolvePrivilegeUserContent(): boolean

networkResurrectLocalPlayer ​

ts
networkResurrectLocalPlayer(x: number, y: number, z: number, heading: number, p4: boolean, changetime: boolean, p6: boolean, p7: number, p8: number): void

networkRetainActivityGroup ​

ts
networkRetainActivityGroup(): void

networkSeedRandomNumberGenerator ​

ts
networkSeedRandomNumberGenerator(seed: number): void

networkSendImportantTransitionInviteViaPresence ​

ts
networkSendImportantTransitionInviteViaPresence(p1: string, datacount: number, p3: number): { gamerhandle: number; return: boolean }

networkSendInviteViaPresence ​

ts
networkSendInviteViaPresence(p1: string, datacount: number, p3: number): { gamerhandle: number; return: boolean }

networkSendQueuedJoinRequest ​

ts
networkSendQueuedJoinRequest(): void

networkSendTextMessage ​

ts
networkSendTextMessage(message: string): { gamerhandle: number; return: boolean }

networkSendTransitionGamerInstruction ​

ts
networkSendTransitionGamerInstruction(p1: string, p2: number, p3: number, p4: boolean): { gamerhandle: number; return: boolean }

networkSendTransitionInviteViaPresence ​

ts
networkSendTransitionInviteViaPresence(p1: string, datacount: number, p3: number): { gamerhandle: number; return: boolean }

networkSessionAddActiveMatchmakingGroup ​

ts
networkSessionAddActiveMatchmakingGroup(groupid: number): void

networkSessionBlockJoinRequests ​

ts
networkSessionBlockJoinRequests(toggle: boolean): void

networkSessionCancelInvite ​

ts
networkSessionCancelInvite(): void

networkSessionChangeSlots ​

ts
networkSessionChangeSlots(slots: number, p1: boolean): void

networkSessionDoActivityQuickmatch ​

ts
networkSessionDoActivityQuickmatch(p0: number, p1: number, p2: number, p3: number, p4: number): boolean

networkSessionDoCrewMatchmaking ​

ts
networkSessionDoCrewMatchmaking(crewid: number, p1: number, p2: number, maxplayers: number): boolean

networkSessionDoFreeroamQuickmatch ​

ts
networkSessionDoFreeroamQuickmatch(p0: number, p1: number, p2: number): boolean

networkSessionDoFriendMatchmaking ​

ts
networkSessionDoFriendMatchmaking(p0: number, p1: number, p2: number): boolean

networkSessionForceCancelInvite ​

ts
networkSessionForceCancelInvite(): void

networkSessionGetHostAimPreference ​

ts
networkSessionGetHostAimPreference(): number

networkSessionGetInviter ​

ts
networkSessionGetInviter(): { gamerhandle: number }

networkSessionGetKickVote ​

ts
networkSessionGetKickVote(player: number): boolean

networkSessionGetMatchmakingGroupFree ​

ts
networkSessionGetMatchmakingGroupFree(p0: number): number

networkSessionGetPrivateSlots ​

ts
networkSessionGetPrivateSlots(): number

networkSessionGetUniqueCrewLimit ​

ts
networkSessionGetUniqueCrewLimit(): number

networkSessionHost ​

ts
networkSessionHost(p0: number, maxplayers: number, p2: boolean): boolean

networkSessionHostClosed ​

ts
networkSessionHostClosed(p0: number, maxplayers: number): boolean

networkSessionHostFriendsOnly ​

ts
networkSessionHostFriendsOnly(p0: number, maxplayers: number): boolean

networkSessionHostSinglePlayer ​

ts
networkSessionHostSinglePlayer(p0: number): void

networkSessionIsAwaitingInviteResponse ​

ts
networkSessionIsAwaitingInviteResponse(): boolean

networkSessionIsClosedCrew ​

ts
networkSessionIsClosedCrew(): boolean

networkSessionIsClosedFriends ​

ts
networkSessionIsClosedFriends(): boolean

networkSessionIsDisplayingInviteConfirmation ​

ts
networkSessionIsDisplayingInviteConfirmation(): boolean

networkSessionIsInVoiceSession ​

ts
networkSessionIsInVoiceSession(): boolean

networkSessionIsPrivate ​

ts
networkSessionIsPrivate(): boolean

networkSessionIsSolo ​

ts
networkSessionIsSolo(): boolean

networkSessionIsVisible ​

ts
networkSessionIsVisible(): boolean

networkSessionIsVoiceSessionActive ​

ts
networkSessionIsVoiceSessionActive(): boolean

networkSessionIsVoiceSessionBusy ​

ts
networkSessionIsVoiceSessionBusy(): boolean

networkSessionJoinInvite ​

ts
networkSessionJoinInvite(): void

networkSessionKickPlayer ​

ts
networkSessionKickPlayer(player: number): void

networkSessionLeave ​

ts
networkSessionLeave(p0: number): boolean

networkSessionLeaveSinglePlayer ​

ts
networkSessionLeaveSinglePlayer(): void

networkSessionMarkVisible ​

ts
networkSessionMarkVisible(toggle: boolean): void

networkSessionReserveSlotsTransition ​

ts
networkSessionReserveSlotsTransition(p0: number, p1: number, p2: number): boolean

networkSessionSetCrewLimitMaxMembersTransition ​

ts
networkSessionSetCrewLimitMaxMembersTransition(p0: number): void

networkSessionSetGamemode ​

ts
networkSessionSetGamemode(p0: number): void

networkSessionSetMatchmakingGroup ​

ts
networkSessionSetMatchmakingGroup(matchmakinggroup: number): void

networkSessionSetMatchmakingGroupMax ​

ts
networkSessionSetMatchmakingGroupMax(playertype: number, playercount: number): void

networkSessionSetMatchmakingMentalState ​

ts
networkSessionSetMatchmakingMentalState(p0: number): void

networkSessionSetMatchmakingPropertyId ​

ts
networkSessionSetMatchmakingPropertyId(p0: boolean): void

networkSessionSetNumBosses ​

ts
networkSessionSetNumBosses(num: number): void

networkSessionSetScriptValidateJoin ​

ts
networkSessionSetScriptValidateJoin(): void

networkSessionSetUniqueCrewLimit ​

ts
networkSessionSetUniqueCrewLimit(p0: number): void

networkSessionSetUniqueCrewLimitTransition ​

ts
networkSessionSetUniqueCrewLimitTransition(p0: number): void

networkSessionSetUniqueCrewOnlyCrewsTransition ​

ts
networkSessionSetUniqueCrewOnlyCrewsTransition(p0: boolean): void

networkSessionValidateJoin ​

ts
networkSessionValidateJoin(p0: boolean): void

networkSessionVoiceConnectToPlayer ​

ts
networkSessionVoiceConnectToPlayer(): { gamerhandle: number }

networkSessionVoiceHost ​

ts
networkSessionVoiceHost(): boolean

networkSessionVoiceLeave ​

ts
networkSessionVoiceLeave(): boolean

networkSessionVoiceRespondToRequest ​

ts
networkSessionVoiceRespondToRequest(p0: boolean, p1: number): void

networkSessionVoiceSetTimeout ​

ts
networkSessionVoiceSetTimeout(timeout: number): void

networkSessionWasInvited ​

ts
networkSessionWasInvited(): boolean

networkSetActivityPlayerMax ​

ts
networkSetActivityPlayerMax(p0: number): void

networkSetActivitySpectator ​

ts
networkSetActivitySpectator(toggle: boolean): void

networkSetActivitySpectatorMax ​

ts
networkSetActivitySpectatorMax(maxspectators: number): void

networkSetAntagonisticToPlayer ​

ts
networkSetAntagonisticToPlayer(toggle: boolean, player: number): void

networkSetAttributeDamageToPlayer ​

ts
networkSetAttributeDamageToPlayer(ped: number, player: number): boolean

networkSetCanReceiveRsInvites ​

ts
networkSetCanReceiveRsInvites(p0: boolean): void

networkSetCurrentChatOption ​

ts
networkSetCurrentChatOption(newchatoption: number): void

networkSetCurrentDataManagerHandle ​

ts
networkSetCurrentDataManagerHandle(): { p0: number; return: boolean }

networkSetCurrentlySelectedGamerHandleFromInviteMenu ​

ts
networkSetCurrentlySelectedGamerHandleFromInviteMenu(): { p0: number; return: boolean }

networkSetCurrentPublicContentId ​

ts
networkSetCurrentPublicContentId(missionid: string): void

networkSetCurrentSpawnLocationOption ​

ts
networkSetCurrentSpawnLocationOption(mpsettingspawn: number): void

networkSetCustomArenaBallParams ​

ts
networkSetCustomArenaBallParams(netid: number): void

networkSetDoNotLaunchFromJoinAsMigratedHost ​

ts
networkSetDoNotLaunchFromJoinAsMigratedHost(toggle: boolean): void

networkSetEntityCanBlend ​

ts
networkSetEntityCanBlend(entity: number, toggle: boolean): void

networkSetEntityOnlyExistsForParticipants ​

ts
networkSetEntityOnlyExistsForParticipants(entity: number, toggle: boolean): void

networkSetFriendlyFireOption ​

ts
networkSetFriendlyFireOption(toggle: boolean): void

networkSetGamerInvitedToTransition ​

ts
networkSetGamerInvitedToTransition(): { gamerhandle: number }

networkSetIgnoreSpectatorChatLimitsSameTeam ​

ts
networkSetIgnoreSpectatorChatLimitsSameTeam(toggle: boolean): void

networkSetInFreeCamMode ​

ts
networkSetInFreeCamMode(toggle: boolean): void

networkSetInMpCutscene ​

ts
networkSetInMpCutscene(p0: boolean, p1: boolean): void

networkSetInProgressFinishTime ​

ts
networkSetInProgressFinishTime(p0: number): void

networkSetInSpectatorMode ​

ts
networkSetInSpectatorMode(toggle: boolean, playerped: number): void

networkSetInSpectatorModeExtended ​

ts
networkSetInSpectatorModeExtended(toggle: boolean, playerped: number, p2: boolean): void

networkSetInviteFailedMessageForInviteMenu ​

ts
networkSetInviteFailedMessageForInviteMenu(): { p0: number; p1: number }

networkSetInviteOnCallForInviteMenu ​

ts
networkSetInviteOnCallForInviteMenu(): { p0: number }

networkSetLocalPlayerInvincibleTime ​

ts
networkSetLocalPlayerInvincibleTime(time: number): void

networkSetLocalPlayerSyncLookAt ​

ts
networkSetLocalPlayerSyncLookAt(toggle: boolean): void

networkSetLookAtTalkers ​

ts
networkSetLookAtTalkers(p0: boolean): void

networkSetMinimumRankForMission ​

ts
networkSetMinimumRankForMission(p0: boolean): void

networkSetMissionFinished ​

ts
networkSetMissionFinished(): void

networkSetNoLongerNeeded ​

ts
networkSetNoLongerNeeded(entity: number, toggle: boolean): void

networkSetNoSpectatorChat ​

ts
networkSetNoSpectatorChat(toggle: boolean): void

networkSetObjectCanBlendWhenFixed ​

ts
networkSetObjectCanBlendWhenFixed(object: number, toggle: boolean): void

networkSetObjectScopeDistance ​

ts
networkSetObjectScopeDistance(object: number, range: number): void

networkSetOverrideSpectatorMode ​

ts
networkSetOverrideSpectatorMode(toggle: boolean): void

networkSetOverrideTutorialSessionChat ​

ts
networkSetOverrideTutorialSessionChat(toggle: boolean): void

networkSetPlayerIsPassive ​

ts
networkSetPlayerIsPassive(toggle: boolean): void

networkSetPlayerMentalState ​

ts
networkSetPlayerMentalState(p0: number): void

networkSetPresenceSessionInvitesBlocked ​

ts
networkSetPresenceSessionInvitesBlocked(toggle: boolean): void

networkSetPrivilegeCheckResultNotNeeded ​

ts
networkSetPrivilegeCheckResultNotNeeded(): void

networkSetProximityAffectsTeam ​

ts
networkSetProximityAffectsTeam(toggle: boolean): void

networkSetRichPresence ​

ts
networkSetRichPresence(p0: number, p1: number, p2: number, p3: number): void

networkSetRichPresenceString ​

ts
networkSetRichPresenceString(p0: number, textlabel: string): void

networkSetSameTeamAsLocalPlayer ​

ts
networkSetSameTeamAsLocalPlayer(p0: number, p1: number): boolean

networkSetScriptAutomuted ​

ts
networkSetScriptAutomuted(p0: number): boolean

networkSetScriptControllingTeams ​

ts
networkSetScriptControllingTeams(p0: number): void

networkSetScriptReadyForEvents ​

ts
networkSetScriptReadyForEvents(toggle: boolean): void

networkSetSpectatorToNonSpectatorTextChat ​

ts
networkSetSpectatorToNonSpectatorTextChat(toggle: boolean): void

networkSetTalkerProximity ​

ts
networkSetTalkerProximity(value: number): void

networkSetTaskCutsceneInscopeMultipler ​

ts
networkSetTaskCutsceneInscopeMultipler(multiplier: number): void

networkSetTeamOnlyChat ​

ts
networkSetTeamOnlyChat(toggle: boolean): void

networkSetThisScriptIsNetworkScript ​

ts
networkSetThisScriptIsNetworkScript(maxnummissionparticipants: number, p1: boolean, instanceid: number): void

networkSetTransitionActivityId ​

ts
networkSetTransitionActivityId(p0: number): void

networkSetTransitionCreatorHandle ​

ts
networkSetTransitionCreatorHandle(): { p0: number }

networkSetTransitionVisibilityLock ​

ts
networkSetTransitionVisibilityLock(p0: boolean, p1: boolean): void

networkSetVehicleDrivenInTestDrive ​

ts
networkSetVehicleDrivenInTestDrive(toggle: boolean): void

networkSetVehicleDrivenLocation ​

ts
networkSetVehicleDrivenLocation(location: number): void

networkSetVoiceActive ​

ts
networkSetVoiceActive(toggle: boolean): void

networkSetVoiceChannel ​

ts
networkSetVoiceChannel(channel: number): void

networkShouldShowPromotionAlertScreen ​

ts
networkShouldShowPromotionAlertScreen(): boolean

networkShouldShowStrictNatWarning ​

ts
networkShouldShowStrictNatWarning(): boolean

networkShowAccountUpgradeUi ​

ts
networkShowAccountUpgradeUi(): void

networkShowChatRestrictionMsc ​

ts
networkShowChatRestrictionMsc(player: number): void

networkShowProfileUi ​

ts
networkShowProfileUi(): { gamerhandle: number }

networkShowPsnUgcRestriction ​

ts
networkShowPsnUgcRestriction(): void

networkSkipRadioResetNextClose ​

ts
networkSkipRadioResetNextClose(): void

networkSkipRadioResetNextOpen ​

ts
networkSkipRadioResetNextOpen(): void

networkSkipRadioWarning ​

ts
networkSkipRadioWarning(): boolean

networkStartRespawnSearchForPlayer ​

ts
networkStartRespawnSearchForPlayer(player: number, x: number, y: number, z: number, radius: number, p5: number, p6: number, p7: number, flags: number): boolean

networkStartRespawnSearchInAngledAreaForPlayer ​

ts
networkStartRespawnSearchInAngledAreaForPlayer(player: number, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, width: number, p8: number, p9: number, p10: number, flags: number): boolean

networkStartSoloTutorialSession ​

ts
networkStartSoloTutorialSession(): void

networkStartSynchronisedScene ​

ts
networkStartSynchronisedScene(netscene: number): void

networkStartUserContentPermissionsCheck ​

ts
networkStartUserContentPermissionsCheck(): { nethandle: number; return: number }

networkStopSynchronisedScene ​

ts
networkStopSynchronisedScene(netscene: number): void

networkStoreInviteThroughRestart ​

ts
networkStoreInviteThroughRestart(): void

networkSuppressInvite ​

ts
networkSuppressInvite(toggle: boolean): void

networkSyncClockTimeOverride ​

ts
networkSyncClockTimeOverride(): void

networkTextChatIsTyping ​

ts
networkTextChatIsTyping(): boolean

networkTransitionAddStage ​

ts
networkTransitionAddStage(hash: number, p1: number, p2: number, state: number, p4: number): boolean

networkTransitionBlockJoinRequests ​

ts
networkTransitionBlockJoinRequests(p0: boolean): void

networkTransitionFinish ​

ts
networkTransitionFinish(p0: number, p1: number, p2: number): boolean

networkTransitionSetActivityIsland ​

ts
networkTransitionSetActivityIsland(p0: number): void

networkTransitionSetContentCreator ​

ts
networkTransitionSetContentCreator(p0: number): void

networkTransitionSetInProgress ​

ts
networkTransitionSetInProgress(p0: number): void

networkTransitionStart ​

ts
networkTransitionStart(p0: number, p1: number, p2: number, p3: number): boolean

networkTriggerDamageEventForZeroDamage ​

ts
networkTriggerDamageEventForZeroDamage(entity: number, toggle: boolean): void

networkTriggerDamageEventForZeroWeaponHash ​

ts
networkTriggerDamageEventForZeroWeaponHash(entity: number, toggle: boolean): void

networkTryAccessTunableBoolHash ​

ts
networkTryAccessTunableBoolHash(tunablecontext: number, tunablename: number, defaultvalue: boolean): boolean

networkTryToSetThisScriptIsNetworkScript ​

ts
networkTryToSetThisScriptIsNetworkScript(p0: number, p1: boolean, p2: number): boolean

networkUgcNav ​

ts
networkUgcNav(p0: number, p1: number): void

networkUnregisterNetworkedEntity ​

ts
networkUnregisterNetworkedEntity(entity: number): void

networkUseHighPrecisionBlending ​

ts
networkUseHighPrecisionBlending(netid: number, toggle: boolean): void

networkUseLogarithmicBlendingThisFrame ​

ts
networkUseLogarithmicBlendingThisFrame(entity: number): void

networkWaitingPopClearTutorialSession ​

ts
networkWaitingPopClearTutorialSession(): boolean

networkWasGameSuspended ​

ts
networkWasGameSuspended(): boolean

objToNet ​

ts
objToNet(object: number): number

openCommerceStore ​

ts
openCommerceStore(p0: string, p1: string, p2: number): void

participantId ​

ts
participantId(): number

participantIdToInt ​

ts
participantIdToInt(): number

pedToNet ​

ts
pedToNet(ped: number): number

refreshPlayerListStats ​

ts
refreshPlayerListStats(p0: number): boolean

releaseAllCommerceItemImages ​

ts
releaseAllCommerceItemImages(): void

removeAllStickyBombsFromEntity ​

ts
removeAllStickyBombsFromEntity(entity: number, ped: number): void

requestCommerceItemImage ​

ts
requestCommerceItemImage(index: number): boolean

reserveLocalNetworkMissionObjects ​

ts
reserveLocalNetworkMissionObjects(amount: number): void

reserveLocalNetworkMissionPeds ​

ts
reserveLocalNetworkMissionPeds(amount: number): void

reserveLocalNetworkMissionVehicles ​

ts
reserveLocalNetworkMissionVehicles(amount: number): void

reserveNetworkMissionObjects ​

ts
reserveNetworkMissionObjects(amount: number): void

reserveNetworkMissionPeds ​

ts
reserveNetworkMissionPeds(amount: number): void

reserveNetworkMissionVehicles ​

ts
reserveNetworkMissionVehicles(amount: number): void

resetGhostAlpha ​

ts
resetGhostAlpha(): void

resetStoreNetworkGameTracking ​

ts
resetStoreNetworkGameTracking(): void

setEntityGhostedForGhostPlayers ​

ts
setEntityGhostedForGhostPlayers(entity: number, toggle: boolean): void

setEntityLocallyInvisible ​

ts
setEntityLocallyInvisible(entity: number): void

setEntityLocallyVisible ​

ts
setEntityLocallyVisible(entity: number): void

setEntityVisibleInCutscene ​

ts
setEntityVisibleInCutscene(p0: number, p1: boolean, p2: boolean): void

setGhostAlpha ​

ts
setGhostAlpha(alpha: number): void

setInvertGhosting ​

ts
setInvertGhosting(p0: boolean): void

setLastViewedShopItem ​

ts
setLastViewedShopItem(p0: number, p1: number, p2: number): void

setLocalPlayerAsGhost ​

ts
setLocalPlayerAsGhost(toggle: boolean, p1: boolean): void

setLocalPlayerInvisibleLocally ​

ts
setLocalPlayerInvisibleLocally(bincludeplayersvehicle: boolean): void

setLocalPlayerVisibleInCutscene ​

ts
setLocalPlayerVisibleInCutscene(p0: boolean, p1: boolean): void

setLocalPlayerVisibleLocally ​

ts
setLocalPlayerVisibleLocally(bincludeplayersvehicle: boolean): void

setNetworkCutsceneEntities ​

ts
setNetworkCutsceneEntities(toggle: boolean): void

setNetworkEnableHighSpeedEdgeFallDetection ​

ts
setNetworkEnableHighSpeedEdgeFallDetection(vehicle: number, toggle: boolean): void

setNetworkIdAlwaysExistsForPlayer ​

ts
setNetworkIdAlwaysExistsForPlayer(netid: number, player: number, toggle: boolean): void

setNetworkIdCanBeReassigned ​

ts
setNetworkIdCanBeReassigned(netid: number, toggle: boolean): void

setNetworkIdCanMigrate ​

ts
setNetworkIdCanMigrate(netid: number, toggle: boolean): void

setNetworkIdExistsOnAllMachines ​

ts
setNetworkIdExistsOnAllMachines(netid: number, toggle: boolean): void

setNetworkIdPassControlInTutorial ​

ts
setNetworkIdPassControlInTutorial(netid: number, state: boolean): void

setNetworkIdVisibleInCutscene ​

ts
setNetworkIdVisibleInCutscene(netid: number, p1: boolean, p2: boolean): void

setNetworkIdVisibleInCutsceneHack ​

ts
setNetworkIdVisibleInCutsceneHack(netid: number, p1: boolean, p2: boolean): void

setNetworkIdVisibleInCutsceneRemainHack ​

ts
setNetworkIdVisibleInCutsceneRemainHack(p0: number, p1: number, p2: number): void

setNetworkVehicleAsGhost ​

ts
setNetworkVehicleAsGhost(vehicle: number, toggle: boolean): void

setNetworkVehicleMaxPositionDeltaMultiplier ​

ts
setNetworkVehicleMaxPositionDeltaMultiplier(vehicle: number, multiplier: number): void

setNetworkVehicleRespotTimer ​

ts
setNetworkVehicleRespotTimer(netid: number, time: number, p2: number, p3: number): void

setNonParticipantsOfThisScriptAsGhosts ​

ts
setNonParticipantsOfThisScriptAsGhosts(p0: boolean): void

setPlayerInvisibleLocally ​

ts
setPlayerInvisibleLocally(player: number, bincludeplayersvehicle: boolean): void

setPlayerVisibleLocally ​

ts
setPlayerVisibleLocally(player: number, bincludeplayersvehicle: boolean): void

setRemotePlayerAsGhost ​

ts
setRemotePlayerAsGhost(player: number, p1: boolean): void

setRemotePlayerVisibleInCutscene ​

ts
setRemotePlayerVisibleInCutscene(player: number, locallyvisible: boolean): void

setStoreEnabled ​

ts
setStoreEnabled(toggle: boolean): void

shutdownAndLaunchSinglePlayerGame ​

ts
shutdownAndLaunchSinglePlayerGame(): void

shutdownAndLoadMostRecentSave ​

ts
shutdownAndLoadMostRecentSave(): boolean

textureDownloadGetName ​

ts
textureDownloadGetName(p0: number): string

textureDownloadHasFailed ​

ts
textureDownloadHasFailed(p0: number): boolean

textureDownloadRelease ​

ts
textureDownloadRelease(p0: number): void

textureDownloadRequest ​

ts
textureDownloadRequest(filepath: string, name: string, p3: boolean): { gamerhandle: number; return: number }

titleTextureDownloadRequest ​

ts
titleTextureDownloadRequest(filepath: string, name: string, p2: boolean): number

triggerCommerceDataFetch ​

ts
triggerCommerceDataFetch(p0: number): void

ugcCancelQuery ​

ts
ugcCancelQuery(): void

ugcClearCreateResult ​

ts
ugcClearCreateResult(): void

ugcClearModifyResult ​

ts
ugcClearModifyResult(): void

ugcClearOfflineQuery ​

ts
ugcClearOfflineQuery(): void

ugcClearQueryResults ​

ts
ugcClearQueryResults(): void

ugcCopyContent ​

ts
ugcCopyContent(): { p0: number; p1: number; return: boolean }

ugcDidCreateSucceed ​

ts
ugcDidCreateSucceed(): boolean

ugcDidDescriptionRequestSucceed ​

ts
ugcDidDescriptionRequestSucceed(p0: number): boolean

ugcDidGetSucceed ​

ts
ugcDidGetSucceed(): boolean

ugcDidModifySucceed ​

ts
ugcDidModifySucceed(): boolean

ugcDidQueryCreatorsSucceed ​

ts
ugcDidQueryCreatorsSucceed(): boolean

ugcGetBookmarkedContent ​

ts
ugcGetBookmarkedContent(p0: number, p1: number, p2: string): { p3: number; return: boolean }

ugcGetCachedDescription ​

ts
ugcGetCachedDescription(p0: number, p1: number): string

ugcGetContentCategory ​

ts
ugcGetContentCategory(p0: number): number

ugcGetContentCreatedByLocalPlayer ​

ts
ugcGetContentCreatedByLocalPlayer(p0: number): boolean

ugcGetContentCreatorGamerHandle ​

ts
ugcGetContentCreatorGamerHandle(p0: number): { p1: number; return: boolean }

ugcGetContentDescription ​

ts
ugcGetContentDescription(index: number): string

ugcGetContentDescriptionHash ​

ts
ugcGetContentDescriptionHash(p0: number): number

ugcGetContentFileVersion ​

ts
ugcGetContentFileVersion(p0: number, p1: number): number

ugcGetContentHash ​

ts
ugcGetContentHash(): number

ugcGetContentHasHiResPhoto ​

ts
ugcGetContentHasHiResPhoto(p0: number): boolean

ugcGetContentHasLoResPhoto ​

ts
ugcGetContentHasLoResPhoto(p0: number): boolean

ugcGetContentHasPlayerBookmarked ​

ts
ugcGetContentHasPlayerBookmarked(p0: number): boolean

ugcGetContentHasPlayerRecord ​

ts
ugcGetContentHasPlayerRecord(p0: number): boolean

ugcGetContentId ​

ts
ugcGetContentId(p0: number): string

ugcGetContentIsPublished ​

ts
ugcGetContentIsPublished(p0: number): boolean

ugcGetContentIsUsingScNickname ​

ts
ugcGetContentIsUsingScNickname(p0: number): boolean

ugcGetContentIsVerified ​

ts
ugcGetContentIsVerified(p0: number): boolean

ugcGetContentLanguage ​

ts
ugcGetContentLanguage(p0: number): number

ugcGetContentName ​

ts
ugcGetContentName(p0: number): string

ugcGetContentNum ​

ts
ugcGetContentNum(): number

ugcGetContentPath ​

ts
ugcGetContentPath(p0: number, p1: number): string

ugcGetContentRating ​

ts
ugcGetContentRating(p0: number, p1: number): number

ugcGetContentRatingCount ​

ts
ugcGetContentRatingCount(p0: number, p1: number): number

ugcGetContentRatingNegativeCount ​

ts
ugcGetContentRatingNegativeCount(p0: number, p1: number): number

ugcGetContentRatingPositiveCount ​

ts
ugcGetContentRatingPositiveCount(p0: number, p1: number): number

ugcGetContentTotal ​

ts
ugcGetContentTotal(): number

ugcGetContentUpdatedDate ​

ts
ugcGetContentUpdatedDate(p0: number): { p1: number }

ugcGetContentUserId ​

ts
ugcGetContentUserId(p0: number): string

ugcGetContentUserName ​

ts
ugcGetContentUserName(p0: number): string

ugcGetCreateContentId ​

ts
ugcGetCreateContentId(): string

ugcGetCreateResult ​

ts
ugcGetCreateResult(): number

ugcGetCreatorNum ​

ts
ugcGetCreatorNum(): number

ugcGetCreatorsByUserId ​

ts
ugcGetCreatorsByUserId(): { p0: number; p1: number; return: boolean }

ugcGetCrewContent ​

ts
ugcGetCrewContent(p0: number, p1: number, p2: number, p3: string): { p4: number; return: boolean }

ugcGetFriendContent ​

ts
ugcGetFriendContent(p0: number, p1: number, p2: string): { p3: number; return: boolean }

ugcGetGetByCategory ​

ts
ugcGetGetByCategory(p0: number, p1: number, p2: number, p3: string): { p4: number; return: boolean }

ugcGetGetByContentId ​

ts
ugcGetGetByContentId(contentid: string, contenttypename: string): boolean

ugcGetGetByContentIds ​

ts
ugcGetGetByContentIds(datacount: number, contenttypename: string): { data: number; return: boolean }

ugcGetModifyResult ​

ts
ugcGetModifyResult(): number

ugcGetMostRecentlyCreatedContent ​

ts
ugcGetMostRecentlyCreatedContent(p0: number, p1: number): { p2: number; p3: number; return: boolean }

ugcGetMostRecentlyPlayedContent ​

ts
ugcGetMostRecentlyPlayedContent(p0: number, p1: number): { p2: number; p3: number; return: boolean }

ugcGetMyContent ​

ts
ugcGetMyContent(p0: number, p1: number, p2: string): { p3: number; return: boolean }

ugcGetQueryResult ​

ts
ugcGetQueryResult(): number

ugcGetRootContentId ​

ts
ugcGetRootContentId(p0: number): string

ugcGetTopRatedContent ​

ts
ugcGetTopRatedContent(p0: number, p1: number): { p2: number; p3: number; return: boolean }

ugcHasCreateFinished ​

ts
ugcHasCreateFinished(): boolean

ugcHasDescriptionRequestFinished ​

ts
ugcHasDescriptionRequestFinished(p0: number): boolean

ugcHasGetFinished ​

ts
ugcHasGetFinished(): boolean

ugcHasModifyFinished ​

ts
ugcHasModifyFinished(): boolean

ugcHasPermissionToWrite ​

ts
ugcHasPermissionToWrite(): boolean

ugcHasQueryCreatorsFinished ​

ts
ugcHasQueryCreatorsFinished(): boolean

ugcIsCreating ​

ts
ugcIsCreating(): boolean

ugcIsDescriptionRequestInProgress ​

ts
ugcIsDescriptionRequestInProgress(p0: number): boolean

ugcIsGetting ​

ts
ugcIsGetting(): boolean

ugcIsLanguageSupported ​

ts
ugcIsLanguageSupported(p0: number): boolean

ugcIsModifying ​

ts
ugcIsModifying(): boolean

ugcLoadOfflineQuery ​

ts
ugcLoadOfflineQuery(p0: number): boolean

ugcPublish ​

ts
ugcPublish(contentid: string, basecontentid: string, contenttypename: string): boolean

ugcQueryByCategory ​

ts
ugcQueryByCategory(p0: number, p1: number, p2: number, p3: string, p4: number, p5: boolean): boolean

ugcQueryByContentId ​

ts
ugcQueryByContentId(contentid: string, latestversion: boolean, contenttypename: string): boolean

ugcQueryByContentIds ​

ts
ugcQueryByContentIds(count: number, latestversion: boolean, contenttypename: string): { data: number; return: boolean }

ugcQueryMostRecentlyCreatedContent ​

ts
ugcQueryMostRecentlyCreatedContent(offset: number, count: number, contenttypename: string, p3: number): boolean

ugcQueryMyContent ​

ts
ugcQueryMyContent(p0: number, p1: number, p3: number, p4: number, p5: number): { p2: number; return: boolean }

ugcReleaseAllCachedDescriptions ​

ts
ugcReleaseAllCachedDescriptions(): void

ugcReleaseCachedDescription ​

ts
ugcReleaseCachedDescription(p0: number): boolean

ugcRequestCachedDescription ​

ts
ugcRequestCachedDescription(p0: number): number

ugcRequestContentDataFromIndex ​

ts
ugcRequestContentDataFromIndex(p0: number, p1: number): number

ugcRequestContentDataFromParams ​

ts
ugcRequestContentDataFromParams(contenttypename: string, contentid: string, p2: number, p3: number, p4: number): number

ugcSetBookmarked ​

ts
ugcSetBookmarked(contentid: string, bookmarked: boolean, contenttypename: string): boolean

ugcSetDeleted ​

ts
ugcSetDeleted(p1: boolean, p2: string): { p0: number; return: boolean }

ugcSetQueryDataFromOffline ​

ts
ugcSetQueryDataFromOffline(p0: boolean): void

ugcSetUsingOfflineContent ​

ts
ugcSetUsingOfflineContent(p0: boolean): void

ugcTextureDownloadRequest ​

ts
ugcTextureDownloadRequest(p0: string, p1: number, p2: number, p3: number, p4: string, p5: boolean): number

ugcWasQueryForceCancelled ​

ts
ugcWasQueryForceCancelled(): boolean

usePlayerColourInsteadOfTeamColour ​

ts
usePlayerColourInsteadOfTeamColour(toggle: boolean): void

vehToNet ​

ts
vehToNet(vehicle: number): number

VIMP developer documentation

Released under the MIT License.