VIMP Docs

English

Русский

English

Русский

Appearance

VimpNativesVehicle ​

@vimp-mp/types 2.0.1

Interface · GTA V natives API

ts
interface VimpNativesVehicle

Members ​

_areMissileBaysDeployed ​

ts
_areMissileBaysDeployed(vehicle: number): boolean

_enableIndividualPlanePropeller ​

ts
_enableIndividualPlanePropeller(vehicle: number, propeller: number): void

_getIsVehicleElectric ​

ts
_getIsVehicleElectric(vehiclemodel: number): boolean

_getRemainingNitrousDuration ​

ts
_getRemainingNitrousDuration(vehicle: number): number

_getVehicleCurrentDriveGear ​

ts
_getVehicleCurrentDriveGear(vehicle: number): number

_getVehicleCurrentRevRatio ​

ts
_getVehicleCurrentRevRatio(vehicle: number): number

_getVehicleDesiredDriveGear ​

ts
_getVehicleDesiredDriveGear(vehicle: number): number

_getVehicleDrivetrainType ​

ts
_getVehicleDrivetrainType(vehiclemodel: number): number

_getVehicleExhaustBone ​

ts
_getVehicleExhaustBone(vehicle: number, index: number): { axisx: boolean; boneindex: number; return: boolean }

_getVehicleMaxDriveGearCount ​

ts
_getVehicleMaxDriveGearCount(vehicle: number): number

_getVehicleMaxExhaustBoneCount ​

ts
_getVehicleMaxExhaustBoneCount(): number

_getVehicleModelNumDriveGears ​

ts
_getVehicleModelNumDriveGears(vehiclemodel: number): number

_getVehicleThrottle ​

ts
_getVehicleThrottle(vehicle: number): number

_getVehicleTrailerParentVehicle ​

ts
_getVehicleTrailerParentVehicle(trailer: number): number

_isVehicleGen9ExclusiveModel ​

ts
_isVehicleGen9ExclusiveModel(vehiclemodel: number): boolean

_isVehicleOnBoostPad ​

ts
_isVehicleOnBoostPad(vehicle: number): boolean

_setAllowCollisionWhenInVehicle ​

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

_setAttachedVehicleToTowTruckArm ​

ts
_setAttachedVehicleToTowTruckArm(towtruck: number, vehicle: number): void

_setBoundsAffectWaterProbes ​

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

_setDeployMissileBays ​

ts
_setDeployMissileBays(vehicle: number, deploy: boolean): void

_setDisableExplodeFromBodyDamageReceivedByAiVehicle ​

ts
_setDisableExplodeFromBodyDamageReceivedByAiVehicle(vehicle: number, disable: boolean): void

_setDriftSlipAngleLimits ​

ts
_setDriftSlipAngleLimits(vehicle: number, durationscalar: number, amplitudescalar: number, slipanglelimit: number): void

_setMinimumTimeBetweenGearShifts ​

ts
_setMinimumTimeBetweenGearShifts(vehicle: number, time: number): void

_setNitrousIsVisible ​

ts
_setNitrousIsVisible(vehicle: number, enabled: boolean): void

_setOverrideTractionLossMultiplier ​

ts
_setOverrideTractionLossMultiplier(vehicle: number, modifier: number): void

_setPlaneAvoidsOthers ​

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

_setRemainingNitrousDuration ​

ts
_setRemainingNitrousDuration(vehicle: number, duration: number): void

_setTransmissionReducedGearRatio ​

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

_setVehicleExplosiveDamageScale ​

ts
_setVehicleExplosiveDamageScale(vehicle: number, scale: number): number

_setVehicleMaxLaunchEngineRevs ​

ts
_setVehicleMaxLaunchEngineRevs(vehicle: number, modifier: number): void

_setVehicleUseHornButtonForNitrous ​

ts
_setVehicleUseHornButtonForNitrous(toggle: boolean): void

addRoadNodeSpeedZone ​

ts
addRoadNodeSpeedZone(x: number, y: number, z: number, radius: number, speed: number, p5: boolean): number

addVehicleCombatAngledAvoidanceArea ​

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

addVehiclePhoneExplosiveDevice ​

ts
addVehiclePhoneExplosiveDevice(vehicle: number): void

addVehicleStuckCheckWithWarp ​

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

addVehicleUpsidedownCheck ​

ts
addVehicleUpsidedownCheck(vehicle: number): void

allowAmbientVehiclesToAvoidAdverseConditions ​

ts
allowAmbientVehiclesToAvoidAdverseConditions(vehicle: number): void

allowBoatBoomToAnimate ​

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

allowTrainToBeRemovedByPopulation ​

ts
allowTrainToBeRemovedByPopulation(p0: number): void

applyEmpEffect ​

ts
applyEmpEffect(vehicle: number): void

areAllVehicleWindowsIntact ​

ts
areAllVehicleWindowsIntact(vehicle: number): boolean

areAnyVehicleSeatsFree ​

ts
areAnyVehicleSeatsFree(vehicle: number): boolean

areFoldingWingsDeployed ​

ts
areFoldingWingsDeployed(vehicle: number): boolean

arePlaneControlPanelsIntact ​

ts
arePlaneControlPanelsIntact(vehicle: number, p1: boolean): boolean

arePlanePropellersIntact ​

ts
arePlanePropellersIntact(plane: number): boolean

areWingsOfPlaneIntact ​

ts
areWingsOfPlaneIntact(plane: number): boolean

attachContainerToHandlerFrameWhenLinedUp ​

ts
attachContainerToHandlerFrameWhenLinedUp(vehicle: number, entity: number): void

attachEntityToCargobob ​

ts
attachEntityToCargobob(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number): void

attachVehicleOnToTrailer ​

ts
attachVehicleOnToTrailer(vehicle: number, trailer: number, offsetx: number, offsety: number, offsetz: number, coordsx: number, coordsy: number, coordsz: number, rotationx: number, rotationy: number, rotationz: number, disablecollisions: number): void

attachVehicleToCargobob ​

ts
attachVehicleToCargobob(cargobob: number, vehicle: number, p2: number, x: number, y: number, z: number): void

attachVehicleToTowTruck ​

ts
attachVehicleToTowTruck(towtruck: number, vehicle: number, rear: boolean, hookoffsetx: number, hookoffsety: number, hookoffsetz: number): void

attachVehicleToTrailer ​

ts
attachVehicleToTrailer(vehicle: number, trailer: number, radius: number): void

bringVehicleToHalt ​

ts
bringVehicleToHalt(vehicle: number, distance: number, duration: number, p3: boolean): void

canAnchorBoatHere ​

ts
canAnchorBoatHere(vehicle: number): boolean

canAnchorBoatHereIgnorePlayers ​

ts
canAnchorBoatHereIgnorePlayers(vehicle: number): boolean

canCargobobPickUpEntity ​

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

canShuffleSeat ​

ts
canShuffleSeat(vehicle: number, seatindex: number): boolean

clearLastDrivenVehicle ​

ts
clearLastDrivenVehicle(): void

clearNitrous ​

ts
clearNitrous(vehicle: number): void

clearVehicleCustomPrimaryColour ​

ts
clearVehicleCustomPrimaryColour(vehicle: number): void

clearVehicleCustomSecondaryColour ​

ts
clearVehicleCustomSecondaryColour(vehicle: number): void

clearVehicleGeneratorAreaOfInterest ​

ts
clearVehicleGeneratorAreaOfInterest(): void

clearVehiclePetroltankFireCulprit ​

ts
clearVehiclePetroltankFireCulprit(vehicle: number): void

clearVehiclePhoneExplosiveDevice ​

ts
clearVehiclePhoneExplosiveDevice(): void

clearVehicleRouteHistory ​

ts
clearVehicleRouteHistory(vehicle: number): void

closeBombBayDoors ​

ts
closeBombBayDoors(vehicle: number): void

controlLandingGear ​

ts
controlLandingGear(vehicle: number, state: number): void

copyVehicleDamages ​

ts
copyVehicleDamages(sourcevehicle: number, targetvehicle: number): void

createMissionTrain ​

ts
createMissionTrain(variation: number, x: number, y: number, z: number, direction: boolean, p5: number, p6: number): number

createPickUpRopeForCargobob ​

ts
createPickUpRopeForCargobob(cargobob: number, state: number): void

createScriptVehicleGenerator ​

ts
createScriptVehicleGenerator(x: number, y: number, z: number, heading: number, p4: number, p5: number, modelhash: number, p7: number, p8: number, p9: number, p10: number, p11: boolean, p12: boolean, p13: boolean, p14: boolean, p15: boolean, p16: number): number

createVehicle ​

ts
createVehicle(modelhash: number, x: number, y: number, z: number, heading: number, isnetwork: boolean, bscripthostveh: boolean, p7: boolean): number

deleteAllTrains ​

ts
deleteAllTrains(): void

deleteMissionTrain ​

ts
deleteMissionTrain(): { train: number }

deleteScriptVehicleGenerator ​

ts
deleteScriptVehicleGenerator(vehiclegenerator: number): void

deleteVehicle ​

ts
deleteVehicle(): { vehicle: number }

detachContainerFromHandlerFrame ​

ts
detachContainerFromHandlerFrame(vehicle: number): void

detachEntityFromCargobob ​

ts
detachEntityFromCargobob(cargobob: number, entity: number): boolean

detachVehicleFromAnyCargobob ​

ts
detachVehicleFromAnyCargobob(vehicle: number): boolean

detachVehicleFromAnyTowTruck ​

ts
detachVehicleFromAnyTowTruck(vehicle: number): boolean

detachVehicleFromCargobob ​

ts
detachVehicleFromCargobob(vehicle: number, cargobob: number): void

detachVehicleFromTowTruck ​

ts
detachVehicleFromTowTruck(towtruck: number, vehicle: number): void

detachVehicleFromTrailer ​

ts
detachVehicleFromTrailer(vehicle: number): void

detonateVehiclePhoneExplosiveDevice ​

ts
detonateVehiclePhoneExplosiveDevice(): void

disableIndividualPlanePropeller ​

ts
disableIndividualPlanePropeller(vehicle: number, propeller: number): void

disablePlaneAileron ​

ts
disablePlaneAileron(vehicle: number, p1: boolean, p2: boolean): void

disableVehcileDynamicAmbientScales ​

ts
disableVehcileDynamicAmbientScales(vehicle: number, p1: number, p2: number): void

disableVehicleExplosionBreakOffParts ​

ts
disableVehicleExplosionBreakOffParts(): void

disableVehicleTurretMovementThisFrame ​

ts
disableVehicleTurretMovementThisFrame(vehicle: number): void

disableVehicleWeapon ​

ts
disableVehicleWeapon(disabled: boolean, weaponhash: number, vehicle: number, owner: number): void

doesCargobobHavePickupMagnet ​

ts
doesCargobobHavePickupMagnet(cargobob: number): boolean

doesCargobobHavePickUpRope ​

ts
doesCargobobHavePickUpRope(cargobob: number): boolean

doesExtraExist ​

ts
doesExtraExist(vehicle: number, extraid: number): boolean

doesScriptVehicleGeneratorExist ​

ts
doesScriptVehicleGeneratorExist(vehiclegenerator: number): boolean

doesVehicleAllowRappel ​

ts
doesVehicleAllowRappel(vehicle: number): boolean

doesVehicleExistWithDecorator ​

ts
doesVehicleExistWithDecorator(decorator: string): number

doesVehicleHaveRoof ​

ts
doesVehicleHaveRoof(vehicle: number): boolean

doesVehicleHaveSearchlight ​

ts
doesVehicleHaveSearchlight(vehicle: number): boolean

doesVehicleHaveStuckVehicleCheck ​

ts
doesVehicleHaveStuckVehicleCheck(vehicle: number): boolean

doesVehicleHaveWeapons ​

ts
doesVehicleHaveWeapons(vehicle: number): boolean

enableVehicleDynamicAmbientScales ​

ts
enableVehicleDynamicAmbientScales(vehicle: number): void

explodeVehicle ​

ts
explodeVehicle(vehicle: number, isaudible: boolean, isinvisible: boolean): void

explodeVehicleInCutscene ​

ts
explodeVehicleInCutscene(vehicle: number, p1: boolean): void

findHandlerVehicleContainerIsAttachedTo ​

ts
findHandlerVehicleContainerIsAttachedTo(entity: number): number

findSpawnCoordinatesForHeli ​

ts
findSpawnCoordinatesForHeli(ped: number): { x: number; y: number; z: number }

fixVehicleWindow ​

ts
fixVehicleWindow(vehicle: number, windowindex: number): void

forcePlaybackRecordedVehicleUpdate ​

ts
forcePlaybackRecordedVehicleUpdate(vehicle: number, p1: boolean): void

forceSubmarineNeurtalBuoyancy ​

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

forceSubmarineSurfaceMode ​

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

forceSubThrottleForTime ​

ts
forceSubThrottleForTime(vehicle: number, p1: number, p2: number): void

fullyChargeNitrous ​

ts
fullyChargeNitrous(vehicle: number): void

generateVehicleCreationPosFromPaths ​

ts
generateVehicleCreationPosFromPaths(p1: number, p3: number, p4: number, p5: number, p6: number, p7: number, p8: number): { outvec: { x: number; y: number; z: number }; outvec1: { x: number; y: number; z: number }; return: boolean }

getAllVehicles ​

ts
getAllVehicles(): { return: number; vehsstruct: number }

getAreBombBayDoorsOpen ​

ts
getAreBombBayDoorsOpen(aircraft: number): boolean

getAttachedPickUpHookPosition ​

ts
getAttachedPickUpHookPosition(cargobob: number): { x: number; y: number; z: number }

getBoatBoomPositionRatio ​

ts
getBoatBoomPositionRatio(vehicle: number): number

getBoatVehicleModelAgility ​

ts
getBoatVehicleModelAgility(modelhash: number): number

getBothVehicleHeadlightsDamaged ​

ts
getBothVehicleHeadlightsDamaged(vehicle: number): boolean

getCanVehicleBePlacedHere ​

ts
getCanVehicleBePlacedHere(vehicle: number, x: number, y: number, z: number, rotx: number, roty: number, rotz: number, p7: number, p8: number): boolean

getCarHasJump ​

ts
getCarHasJump(vehicle: number): boolean

getClosestVehicle ​

ts
getClosestVehicle(x: number, y: number, z: number, radius: number, modelhash: number, flags: number): number

getConvertibleRoofState ​

ts
getConvertibleRoofState(vehicle: number): number

getCurrentPlaybackForVehicle ​

ts
getCurrentPlaybackForVehicle(vehicle: number): number

getDisplayNameFromVehicleModel ​

ts
getDisplayNameFromVehicleModel(modelhash: number): string

getDoesVehicleHaveDamageDecals ​

ts
getDoesVehicleHaveDamageDecals(vehicle: number): boolean

getDoesVehicleHaveTombstone ​

ts
getDoesVehicleHaveTombstone(vehicle: number): boolean

getDriftTyresSet ​

ts
getDriftTyresSet(vehicle: number): boolean

getEntityAttachedToCargobob ​

ts
getEntityAttachedToCargobob(p0: number): number

getEntityAttachedToTowTruck ​

ts
getEntityAttachedToTowTruck(towtruck: number): number

getEntryPointPosition ​

ts
getEntryPointPosition(vehicle: number, doorid: number): { x: number; y: number; z: number }

getFakeSuspensionLoweringAmount ​

ts
getFakeSuspensionLoweringAmount(vehicle: number): number

getFlyingVehicleModelAgility ​

ts
getFlyingVehicleModelAgility(modelhash: number): number

getHasRetractableWheels ​

ts
getHasRetractableWheels(vehicle: number): boolean

getHasRocketBoost ​

ts
getHasRocketBoost(vehicle: number): boolean

getHasVehicleBeenHitByShunt ​

ts
getHasVehicleBeenHitByShunt(vehicle: number): boolean

getHeliMainRotorHealth ​

ts
getHeliMainRotorHealth(vehicle: number): number

getHeliTailBoomHealth ​

ts
getHeliTailBoomHealth(vehicle: number): number

getHeliTailRotorHealth ​

ts
getHeliTailRotorHealth(vehicle: number): number

getHydraulicSuspensionRaiseFactor ​

ts
getHydraulicSuspensionRaiseFactor(vehicle: number, wheelid: number): number

getInVehicleClipsetHashForSeat ​

ts
getInVehicleClipsetHashForSeat(vehicle: number, p1: number): number

getIsBoatCapsized ​

ts
getIsBoatCapsized(vehicle: number): boolean

getIsDoorValid ​

ts
getIsDoorValid(vehicle: number, doorid: number): boolean

getIsLeftVehicleHeadlightDamaged ​

ts
getIsLeftVehicleHeadlightDamaged(vehicle: number): boolean

getIsRightVehicleHeadlightDamaged ​

ts
getIsRightVehicleHeadlightDamaged(vehicle: number): boolean

getIsVehicleDisabledByEmp ​

ts
getIsVehicleDisabledByEmp(vehicle: number): boolean

getIsVehicleEngineRunning ​

ts
getIsVehicleEngineRunning(vehicle: number): boolean

getIsVehiclePrimaryColourCustom ​

ts
getIsVehiclePrimaryColourCustom(vehicle: number): boolean

getIsVehicleSecondaryColourCustom ​

ts
getIsVehicleSecondaryColourCustom(vehicle: number): boolean

getIsVehicleShunting ​

ts
getIsVehicleShunting(vehicle: number): boolean

getIsWheelsRetracted ​

ts
getIsWheelsRetracted(vehicle: number): boolean

getLandingGearState ​

ts
getLandingGearState(vehicle: number): number

getLastDrivenVehicle ​

ts
getLastDrivenVehicle(): number

getLastPedInVehicleSeat ​

ts
getLastPedInVehicleSeat(vehicle: number, seatindex: number): number

getLastShuntVehicle ​

ts
getLastShuntVehicle(vehicle: number): number

getLiveryName ​

ts
getLiveryName(vehicle: number, liveryindex: number): string

getMakeNameFromVehicleModel ​

ts
getMakeNameFromVehicleModel(modelhash: number): string

getModSlotName ​

ts
getModSlotName(vehicle: number, modtype: number): string

getModTextLabel ​

ts
getModTextLabel(vehicle: number, modtype: number, modvalue: number): string

getNumberOfVehicleColours ​

ts
getNumberOfVehicleColours(vehicle: number): number

getNumberOfVehicleDoors ​

ts
getNumberOfVehicleDoors(vehicle: number): number

getNumberOfVehicleNumberPlates ​

ts
getNumberOfVehicleNumberPlates(): number

getNumModColors ​

ts
getNumModColors(painttype: number, p1: boolean): number

getNumModKits ​

ts
getNumModKits(vehicle: number): number

getNumVehicleMods ​

ts
getNumVehicleMods(vehicle: number, modtype: number): number

getNumVehicleWindowTints ​

ts
getNumVehicleWindowTints(): number

getOutriggersDeployed ​

ts
getOutriggersDeployed(vehicle: number): boolean

getPedInVehicleSeat ​

ts
getPedInVehicleSeat(vehicle: number, seatindex: number, p2: boolean): number

getPedUsingVehicleDoor ​

ts
getPedUsingVehicleDoor(vehicle: number, doord: number): number

getPositionInRecording ​

ts
getPositionInRecording(vehicle: number): number

getPositionOfVehicleRecordingAtTime ​

ts
getPositionOfVehicleRecordingAtTime(recording: number, time: number, script: string): { x: number; y: number; z: number }

getPositionOfVehicleRecordingIdAtTime ​

ts
getPositionOfVehicleRecordingIdAtTime(id: number, time: number): { x: number; y: number; z: number }

getRandomVehicleBackBumperInSphere ​

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

getRandomVehicleFrontBumperInSphere ​

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

getRandomVehicleInSphere ​

ts
getRandomVehicleInSphere(x: number, y: number, z: number, radius: number, modelhash: number, flags: number): number

getRandomVehicleModelInMemory ​

ts
getRandomVehicleModelInMemory(p0: boolean): { modelhash: number; successindicator: number }

getRotationOfVehicleRecordingAtTime ​

ts
getRotationOfVehicleRecordingAtTime(recording: number, time: number, script: string): { x: number; y: number; z: number }

getRotationOfVehicleRecordingIdAtTime ​

ts
getRotationOfVehicleRecordingIdAtTime(id: number, time: number): { x: number; y: number; z: number }

getSubmarineIsUnderDesignDepth ​

ts
getSubmarineIsUnderDesignDepth(submarine: number): boolean

getSubmarineNumberOfAirLeaks ​

ts
getSubmarineNumberOfAirLeaks(submarine: number): number

getTimePositionInRecording ​

ts
getTimePositionInRecording(vehicle: number): number

getTotalDurationOfVehicleRecording ​

ts
getTotalDurationOfVehicleRecording(recording: number, script: string): number

getTotalDurationOfVehicleRecordingId ​

ts
getTotalDurationOfVehicleRecordingId(id: number): number

getTrainCarriage ​

ts
getTrainCarriage(train: number, trailernumber: number): number

getTyreHealth ​

ts
getTyreHealth(vehicle: number, wheelindex: number): number

getTyreWearRate ​

ts
getTyreWearRate(vehicle: number, wheelindex: number): number

getVehicleAcceleration ​

ts
getVehicleAcceleration(vehicle: number): number

getVehicleAttachedToCargobob ​

ts
getVehicleAttachedToCargobob(cargobob: number): number

getVehicleBodyHealth ​

ts
getVehicleBodyHealth(vehicle: number): number

getVehicleBombAmmo ​

ts
getVehicleBombAmmo(vehicle: number): number

getVehicleCanDeployParachute ​

ts
getVehicleCanDeployParachute(vehicle: number): boolean

getVehicleCauseOfDestruction ​

ts
getVehicleCauseOfDestruction(vehicle: number): number

getVehicleClass ​

ts
getVehicleClass(vehicle: number): number

getVehicleClassEstimatedMaxSpeed ​

ts
getVehicleClassEstimatedMaxSpeed(vehicleclass: number): number

getVehicleClassFromName ​

ts
getVehicleClassFromName(modelhash: number): number

getVehicleClassMaxAcceleration ​

ts
getVehicleClassMaxAcceleration(vehicleclass: number): number

getVehicleClassMaxAgility ​

ts
getVehicleClassMaxAgility(vehicleclass: number): number

getVehicleClassMaxBraking ​

ts
getVehicleClassMaxBraking(vehicleclass: number): number

getVehicleClassMaxTraction ​

ts
getVehicleClassMaxTraction(vehicleclass: number): number

getVehicleColor ​

ts
getVehicleColor(vehicle: number): { b: number; g: number; r: number }

getVehicleColourCombination ​

ts
getVehicleColourCombination(vehicle: number): number

getVehicleColours ​

ts
getVehicleColours(vehicle: number): { colorprimary: number; colorsecondary: number }

getVehicleColoursWhichCanBeSet ​

ts
getVehicleColoursWhichCanBeSet(vehicle: number): number

getVehicleCountermeasureAmmo ​

ts
getVehicleCountermeasureAmmo(vehicle: number): number

getVehicleCurrentTimeInSlipStream ​

ts
getVehicleCurrentTimeInSlipStream(vehicle: number): number

getVehicleCustomPrimaryColour ​

ts
getVehicleCustomPrimaryColour(vehicle: number): { b: number; g: number; r: number }

getVehicleCustomSecondaryColour ​

ts
getVehicleCustomSecondaryColour(vehicle: number): { b: number; g: number; r: number }

getVehicleDeformationAtPos ​

ts
getVehicleDeformationAtPos(vehicle: number, offsetx: number, offsety: number, offsetz: number): { x: number; y: number; z: number }

getVehicleDirtLevel ​

ts
getVehicleDirtLevel(vehicle: number): number

getVehicleDoorAngleRatio ​

ts
getVehicleDoorAngleRatio(vehicle: number, doorid: number): number

getVehicleDoorLockStatus ​

ts
getVehicleDoorLockStatus(vehicle: number): number

getVehicleDoorsLockedForPlayer ​

ts
getVehicleDoorsLockedForPlayer(vehicle: number, player: number): boolean

getVehicleEngineHealth ​

ts
getVehicleEngineHealth(vehicle: number): number

getVehicleEnveffScale ​

ts
getVehicleEnveffScale(vehicle: number): number

getVehicleEstimatedMaxSpeed ​

ts
getVehicleEstimatedMaxSpeed(vehicle: number): number

getVehicleExtraColour5 ​

ts
getVehicleExtraColour5(vehicle: number): { color: number }

getVehicleExtraColour6 ​

ts
getVehicleExtraColour6(vehicle: number): { color: number }

getVehicleExtraColours ​

ts
getVehicleExtraColours(vehicle: number): { pearlescentcolor: number; wheelcolor: number }

getVehicleFlightNozzlePosition ​

ts
getVehicleFlightNozzlePosition(plane: number): number

getVehicleHasKers ​

ts
getVehicleHasKers(vehicle: number): boolean

getVehicleHasLandingGear ​

ts
getVehicleHasLandingGear(vehicle: number): boolean

getVehicleHasParachute ​

ts
getVehicleHasParachute(vehicle: number): boolean

getVehicleHealthPercentage ​

ts
getVehicleHealthPercentage(vehicle: number, maxenginehealth: number, maxpetroltankhealth: number, maxbodyhealth: number, maxmainrotorhealth: number, maxtailrotorhealth: number, maxunkhealth: number): number

getVehicleHomingLockedontoState ​

ts
getVehicleHomingLockedontoState(p0: number): number

getVehicleHomingLockonState ​

ts
getVehicleHomingLockonState(vehicle: number): number

getVehicleIndividualDoorLockStatus ​

ts
getVehicleIndividualDoorLockStatus(vehicle: number, doorid: number): number

getVehicleIsDummy ​

ts
getVehicleIsDummy(p0: number): boolean

getVehicleIsMercenary ​

ts
getVehicleIsMercenary(vehicle: number): boolean

getVehicleLayoutHash ​

ts
getVehicleLayoutHash(vehicle: number): number

getVehicleLightsState ​

ts
getVehicleLightsState(vehicle: number): { highbeamson: boolean; lightson: boolean; return: boolean }

getVehicleLivery ​

ts
getVehicleLivery(vehicle: number): number

getVehicleLivery2 ​

ts
getVehicleLivery2(vehicle: number): number

getVehicleLivery2Count ​

ts
getVehicleLivery2Count(vehicle: number): number

getVehicleLiveryCount ​

ts
getVehicleLiveryCount(vehicle: number): number

getVehicleLockOnTarget ​

ts
getVehicleLockOnTarget(vehicle: number): { entity: number; return: boolean }

getVehicleMaxBraking ​

ts
getVehicleMaxBraking(vehicle: number): number

getVehicleMaxNumberOfPassengers ​

ts
getVehicleMaxNumberOfPassengers(vehicle: number): number

getVehicleMaxTraction ​

ts
getVehicleMaxTraction(vehicle: number): number

getVehicleMod ​

ts
getVehicleMod(vehicle: number, modtype: number): number

getVehicleModColor1 ​

ts
getVehicleModColor1(vehicle: number): { color: number; painttype: number; pearlescentcolor: number }

getVehicleModColor1Name ​

ts
getVehicleModColor1Name(vehicle: number, p1: boolean): string

getVehicleModColor2 ​

ts
getVehicleModColor2(vehicle: number): { color: number; painttype: number }

getVehicleModColor2Name ​

ts
getVehicleModColor2Name(vehicle: number): string

getVehicleModelAcceleration ​

ts
getVehicleModelAcceleration(modelhash: number): number

getVehicleModelAccelerationMaxMods ​

ts
getVehicleModelAccelerationMaxMods(modelhash: number): number

getVehicleModelEstimatedMaxSpeed ​

ts
getVehicleModelEstimatedMaxSpeed(modelhash: number): number

getVehicleModelMaxBraking ​

ts
getVehicleModelMaxBraking(modelhash: number): number

getVehicleModelMaxBrakingMaxMods ​

ts
getVehicleModelMaxBrakingMaxMods(modelhash: number): number

getVehicleModelMaxTraction ​

ts
getVehicleModelMaxTraction(modelhash: number): number

getVehicleModelNumberOfSeats ​

ts
getVehicleModelNumberOfSeats(modelhash: number): number

getVehicleModelValue ​

ts
getVehicleModelValue(vehiclemodel: number): number

getVehicleModIdentifierHash ​

ts
getVehicleModIdentifierHash(vehicle: number, modtype: number, modindex: number): number

getVehicleModKit ​

ts
getVehicleModKit(vehicle: number): number

getVehicleModKitType ​

ts
getVehicleModKitType(vehicle: number): number

getVehicleModModifierValue ​

ts
getVehicleModModifierValue(vehicle: number, modtype: number, modindex: number): number

getVehicleModVariation ​

ts
getVehicleModVariation(vehicle: number, modtype: number): number

getVehicleNeonColour ​

ts
getVehicleNeonColour(vehicle: number): { b: number; g: number; r: number }

getVehicleNeonEnabled ​

ts
getVehicleNeonEnabled(vehicle: number, index: number): boolean

getVehicleNumberOfPassengers ​

ts
getVehicleNumberOfPassengers(vehicle: number, includedriver: boolean, includedeadoccupants: boolean): number

getVehicleNumberPlateText ​

ts
getVehicleNumberPlateText(vehicle: number): string

getVehicleNumberPlateTextIndex ​

ts
getVehicleNumberPlateTextIndex(vehicle: number): number

getVehicleNumOfBrokenLoosenParts ​

ts
getVehicleNumOfBrokenLoosenParts(vehicle: number): number

getVehicleNumOfBrokenOffParts ​

ts
getVehicleNumOfBrokenOffParts(vehicle: number): number

getVehiclePetrolTankHealth ​

ts
getVehiclePetrolTankHealth(vehicle: number): number

getVehiclePlateType ​

ts
getVehiclePlateType(vehicle: number): number

getVehicleRecordingId ​

ts
getVehicleRecordingId(recording: number, script: string): number

getVehicleSize ​

ts
getVehicleSize(vehicle: number): { out1: { x: number; y: number; z: number }; out2: { x: number; y: number; z: number } }

getVehicleTrailerVehicle ​

ts
getVehicleTrailerVehicle(vehicle: number): { return: boolean; trailer: number }

getVehicleTyresCanBurst ​

ts
getVehicleTyresCanBurst(vehicle: number): boolean

getVehicleTyreSmokeColor ​

ts
getVehicleTyreSmokeColor(vehicle: number): { b: number; g: number; r: number }

getVehicleWeaponRestrictedAmmo ​

ts
getVehicleWeaponRestrictedAmmo(vehicle: number, weaponindex: number): number

getVehicleWheelType ​

ts
getVehicleWheelType(vehicle: number): number

getVehicleWindowTint ​

ts
getVehicleWindowTint(vehicle: number): number

getVehicleXenonLightColorIndex ​

ts
getVehicleXenonLightColorIndex(vehicle: number): number

hasInstantFillVehiclePopulationFinished ​

ts
hasInstantFillVehiclePopulationFinished(): boolean

hasPreloadModsFinished ​

ts
hasPreloadModsFinished(vehicle: number): boolean

hasVehicleAssetLoaded ​

ts
hasVehicleAssetLoaded(vehicleasset: number): boolean

hasVehiclePetroltankSetOnFireByEntity ​

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

hasVehiclePhoneExplosiveDevice ​

ts
hasVehiclePhoneExplosiveDevice(): boolean

hasVehicleRecordingBeenLoaded ​

ts
hasVehicleRecordingBeenLoaded(recording: number, script: string): boolean

haveVehicleModsStreamedIn ​

ts
haveVehicleModsStreamedIn(vehicle: number): boolean

haveVehicleRearDoorsBeenBlownOpenByStickybomb ​

ts
haveVehicleRearDoorsBeenBlownOpenByStickybomb(vehicle: number): boolean

hideTombstone ​

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

instantlyFillVehiclePopulation ​

ts
instantlyFillVehiclePopulation(): void

isAnyEntityAttachedToHandlerFrame ​

ts
isAnyEntityAttachedToHandlerFrame(vehicle: number): boolean

isAnyPedRappellingFromHeli ​

ts
isAnyPedRappellingFromHeli(vehicle: number): boolean

isAnyVehicleNearPoint ​

ts
isAnyVehicleNearPoint(x: number, y: number, z: number, radius: number): boolean

isBigVehicle ​

ts
isBigVehicle(vehicle: number): boolean

isBoatAnchored ​

ts
isBoatAnchored(vehicle: number): boolean

isCopVehicleInArea3d ​

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

isEntityAttachedToHandlerFrame ​

ts
isEntityAttachedToHandlerFrame(vehicle: number, entity: number): boolean

isEntryPointForSeatClear ​

ts
isEntryPointForSeatClear(ped: number, vehicle: number, seatindex: number, side: boolean, onenter: boolean): boolean

isExtraBrokenOff ​

ts
isExtraBrokenOff(vehicle: number, extraid: number): boolean

isHandlerFrameLinedUpWithContainer ​

ts
isHandlerFrameLinedUpWithContainer(vehicle: number, entity: number): boolean

isHeliLandingAreaBlocked ​

ts
isHeliLandingAreaBlocked(vehicle: number): boolean

isHeliPartBroken ​

ts
isHeliPartBroken(vehicle: number, p1: boolean, p2: boolean, p3: boolean): boolean

isMissionTrain ​

ts
isMissionTrain(train: number): boolean

isNitrousActive ​

ts
isNitrousActive(vehicle: number): boolean

isPedExclusiveDriverOfVehicle ​

ts
isPedExclusiveDriverOfVehicle(ped: number, vehicle: number): { outindex: number; return: boolean }

isPlaneLandingGearIntact ​

ts
isPlaneLandingGearIntact(plane: number): boolean

isPlaybackGoingOnForVehicle ​

ts
isPlaybackGoingOnForVehicle(vehicle: number): boolean

isPlaybackUsingAiGoingOnForVehicle ​

ts
isPlaybackUsingAiGoingOnForVehicle(vehicle: number): boolean

isRocketBoostActive ​

ts
isRocketBoostActive(vehicle: number): boolean

isSeatWarpOnly ​

ts
isSeatWarpOnly(vehicle: number, seatindex: number): boolean

isTaxiLightOn ​

ts
isTaxiLightOn(vehicle: number): boolean

isThisModelABicycle ​

ts
isThisModelABicycle(model: number): boolean

isThisModelABike ​

ts
isThisModelABike(model: number): boolean

isThisModelABoat ​

ts
isThisModelABoat(model: number): boolean

isThisModelACar ​

ts
isThisModelACar(model: number): boolean

isThisModelAHeli ​

ts
isThisModelAHeli(model: number): boolean

isThisModelAJetski ​

ts
isThisModelAJetski(model: number): boolean

isThisModelAnAmphibiousCar ​

ts
isThisModelAnAmphibiousCar(model: number): boolean

isThisModelAnAmphibiousQuadbike ​

ts
isThisModelAnAmphibiousQuadbike(model: number): boolean

isThisModelAPlane ​

ts
isThisModelAPlane(model: number): boolean

isThisModelAQuadbike ​

ts
isThisModelAQuadbike(model: number): boolean

isThisModelATrain ​

ts
isThisModelATrain(model: number): boolean

isToggleModOn ​

ts
isToggleModOn(vehicle: number, modtype: number): boolean

isTurretSeat ​

ts
isTurretSeat(vehicle: number, seatindex: number): boolean

isVehicleAConvertible ​

ts
isVehicleAConvertible(vehicle: number, p1: boolean): boolean

isVehicleAlarmActivated ​

ts
isVehicleAlarmActivated(vehicle: number): boolean

isVehicleAttachedToCargobob ​

ts
isVehicleAttachedToCargobob(cargobob: number, vehicleattached: number): boolean

isVehicleAttachedToTowTruck ​

ts
isVehicleAttachedToTowTruck(towtruck: number, vehicle: number): boolean

isVehicleAttachedToTrailer ​

ts
isVehicleAttachedToTrailer(vehicle: number): boolean

isVehicleBeingBroughtToHalt ​

ts
isVehicleBeingBroughtToHalt(vehicle: number): boolean

isVehicleBumperBouncing ​

ts
isVehicleBumperBouncing(vehicle: number, frontbumper: boolean): boolean

isVehicleBumperBrokenOff ​

ts
isVehicleBumperBrokenOff(vehicle: number, frontbumper: boolean): boolean

isVehicleDoorDamaged ​

ts
isVehicleDoorDamaged(veh: number, doorid: number): boolean

isVehicleDoorFullyOpen ​

ts
isVehicleDoorFullyOpen(vehicle: number, doorid: number): boolean

isVehicleDriveable ​

ts
isVehicleDriveable(vehicle: number, isonfirecheck: boolean): boolean

isVehicleExtraTurnedOn ​

ts
isVehicleExtraTurnedOn(vehicle: number, extraid: number): boolean

isVehicleHighDetail ​

ts
isVehicleHighDetail(vehicle: number): boolean

isVehicleInBurnout ​

ts
isVehicleInBurnout(vehicle: number): boolean

isVehicleInGarageArea ​

ts
isVehicleInGarageArea(garagename: string, vehicle: number): boolean

isVehicleInSubmarineMode ​

ts
isVehicleInSubmarineMode(vehicle: number): boolean

isVehicleModel ​

ts
isVehicleModel(vehicle: number, model: number): boolean

isVehicleModGen9Exclusive ​

ts
isVehicleModGen9Exclusive(vehicle: number, modtype: number, modindex: number): boolean

isVehicleOnAllWheels ​

ts
isVehicleOnAllWheels(vehicle: number): boolean

isVehicleParachuteDeployed ​

ts
isVehicleParachuteDeployed(vehicle: number): boolean

isVehicleProducingSlipStream ​

ts
isVehicleProducingSlipStream(vehicle: number): boolean

isVehicleSearchlightOn ​

ts
isVehicleSearchlightOn(vehicle: number): boolean

isVehicleSeatFree ​

ts
isVehicleSeatFree(vehicle: number, seatindex: number, istaskrunning: boolean): boolean

isVehicleSirenAudioOn ​

ts
isVehicleSirenAudioOn(vehicle: number): boolean

isVehicleSirenOn ​

ts
isVehicleSirenOn(vehicle: number): boolean

isVehicleSprayable ​

ts
isVehicleSprayable(vehicle: number): boolean

isVehicleStolen ​

ts
isVehicleStolen(vehicle: number): boolean

isVehicleStopped ​

ts
isVehicleStopped(vehicle: number): boolean

isVehicleStoppedAtTrafficLights ​

ts
isVehicleStoppedAtTrafficLights(vehicle: number): boolean

isVehicleStuckOnRoof ​

ts
isVehicleStuckOnRoof(vehicle: number): boolean

isVehicleStuckTimerUp ​

ts
isVehicleStuckTimerUp(vehicle: number, p1: number, ms: number): boolean

isVehicleTyreBurst ​

ts
isVehicleTyreBurst(vehicle: number, wheelid: number, completely: boolean): boolean

isVehicleVisible ​

ts
isVehicleVisible(vehicle: number): boolean

isVehicleWeaponDisabled ​

ts
isVehicleWeaponDisabled(weaponhash: number, vehicle: number, owner: number): boolean

isVehicleWindowIntact ​

ts
isVehicleWindowIntact(vehicle: number, windowindex: number): boolean

lockDoorsWhenNoLongerNeeded ​

ts
lockDoorsWhenNoLongerNeeded(vehicle: number): void

lowerConvertibleRoof ​

ts
lowerConvertibleRoof(vehicle: number, instantlylower: boolean): void

lowerForkliftForks ​

ts
lowerForkliftForks(forklift: number): void

modifyVehicleTopSpeed ​

ts
modifyVehicleTopSpeed(vehicle: number, value: number): void

networkCapEmptyCrowdingVehiclesRemoval ​

ts
networkCapEmptyCrowdingVehiclesRemoval(p0: number): void

networkEnableEmptyCrowdingVehiclesRemoval ​

ts
networkEnableEmptyCrowdingVehiclesRemoval(toggle: boolean): void

networkUseHighPrecisionTrainBlending ​

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

openBombBayDoors ​

ts
openBombBayDoors(vehicle: number): void

overridePlaneDamageThrehsold ​

ts
overridePlaneDamageThrehsold(vehicle: number, health: number): void

pausePlaybackRecordedVehicle ​

ts
pausePlaybackRecordedVehicle(vehicle: number): void

popOffVehicleRoofWithImpulse ​

ts
popOffVehicleRoofWithImpulse(vehicle: number, x: number, y: number, z: number): void

popOutVehicleWindscreen ​

ts
popOutVehicleWindscreen(vehicle: number): void

preloadVehicleMod ​

ts
preloadVehicleMod(vehicle: number, modtype: number, modindex: number): void

raiseConvertibleRoof ​

ts
raiseConvertibleRoof(vehicle: number, instantlyraise: boolean): void

releasePreloadMods ​

ts
releasePreloadMods(vehicle: number): void

removePickUpRopeForCargobob ​

ts
removePickUpRopeForCargobob(cargobob: number): void

removeRoadNodeSpeedZone ​

ts
removeRoadNodeSpeedZone(speedzone: number): boolean

removeVehicleAsset ​

ts
removeVehicleAsset(vehicleasset: number): void

removeVehicleCombatAvoidanceArea ​

ts
removeVehicleCombatAvoidanceArea(p0: number): void

removeVehicleHighDetailModel ​

ts
removeVehicleHighDetailModel(vehicle: number): void

removeVehicleMod ​

ts
removeVehicleMod(vehicle: number, modtype: number): void

removeVehicleRecording ​

ts
removeVehicleRecording(recording: number, script: string): void

removeVehiclesFromGeneratorsInArea ​

ts
removeVehiclesFromGeneratorsInArea(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, p6: number): void

removeVehicleStuckCheck ​

ts
removeVehicleStuckCheck(vehicle: number): void

removeVehicleUpsidedownCheck ​

ts
removeVehicleUpsidedownCheck(vehicle: number): void

removeVehicleWindow ​

ts
removeVehicleWindow(vehicle: number, windowindex: number): void

requestVehicleAsset ​

ts
requestVehicleAsset(vehiclehash: number, vehicleasset: number): void

requestVehicleDial ​

ts
requestVehicleDial(vehicle: number): void

requestVehicleHighDetailModel ​

ts
requestVehicleHighDetailModel(vehicle: number): void

requestVehicleRecording ​

ts
requestVehicleRecording(recording: number, script: string): void

resetFormationLeader ​

ts
resetFormationLeader(): void

resetVehicleStuckTimer ​

ts
resetVehicleStuckTimer(vehicle: number, nullattributes: number): void

resetVehicleWheels ​

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

rollDownWindow ​

ts
rollDownWindow(vehicle: number, windowindex: number): void

rollDownWindows ​

ts
rollDownWindows(vehicle: number): void

rollUpWindow ​

ts
rollUpWindow(vehicle: number, windowindex: number): void

setAdditionalRotationForRecordedVehiclePlayback ​

ts
setAdditionalRotationForRecordedVehiclePlayback(vehicle: number, x: number, y: number, z: number, p4: number): void

setAircraftIgnoreHightmapOptimisation ​

ts
setAircraftIgnoreHightmapOptimisation(vehicle: number, p1: number): void

setAircraftPilotSkillNoiseScalar ​

ts
setAircraftPilotSkillNoiseScalar(vehicle: number, p1: number): void

setAllLowPriorityVehicleGeneratorsActive ​

ts
setAllLowPriorityVehicleGeneratorsActive(active: boolean): void

setAllowRammingSoopOrRamp ​

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

setAllowVehicleExplodesOnContact ​

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

setAllVehicleGeneratorsActive ​

ts
setAllVehicleGeneratorsActive(): void

setAllVehicleGeneratorsActiveInArea ​

ts
setAllVehicleGeneratorsActiveInArea(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, toggle: boolean, p7: boolean): void

setAmbientVehicleNeonEnabled ​

ts
setAmbientVehicleNeonEnabled(p0: boolean): void

setAmbientVehicleRangeMultiplierThisFrame ​

ts
setAmbientVehicleRangeMultiplierThisFrame(value: number): void

setArriveDistanceOverrideForVehiclePersuitAttack ​

ts
setArriveDistanceOverrideForVehiclePersuitAttack(vehicle: number, p1: number): void

setBikeEasyToLand ​

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

setBikeOnStand ​

ts
setBikeOnStand(vehicle: number, x: number, y: number): void

setBoatAnchor ​

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

setBoatDisableAvoidance ​

ts
setBoatDisableAvoidance(vehicle: number, p1: boolean): void

setBoatIgnoreLandProbes ​

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

setBoatLowLodAnchorDistance ​

ts
setBoatLowLodAnchorDistance(vehicle: number, value: number): void

setBoatRemainsAnchoredWhilePlayerIsDriver ​

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

setBoatSinksWhenWrecked ​

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

setBoatWrecked ​

ts
setBoatWrecked(vehicle: number): void

setCanAdjustGroundClearance ​

ts
setCanAdjustGroundClearance(vehicle: number, p1: boolean): void

setCanResprayVehicle ​

ts
setCanResprayVehicle(vehicle: number, state: boolean): void

setCanUseHydraulics ​

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

setCarBootOpen ​

ts
setCarBootOpen(vehicle: number): void

setCargobobExcludeFromPickupEntity ​

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

setCargobobExtaPickupRange ​

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

setCargobobForceDontDetachVehicle ​

ts
setCargobobForceDontDetachVehicle(cargobob: number, toggle: boolean): void

setCargobobPickupMagnetActive ​

ts
setCargobobPickupMagnetActive(cargobob: number, isactive: boolean): void

setCargobobPickupMagnetEnsurePickupEntityUpright ​

ts
setCargobobPickupMagnetEnsurePickupEntityUpright(vehicle: number, p1: boolean): void

setCargobobPickupMagnetFalloff ​

ts
setCargobobPickupMagnetFalloff(cargobob: number, p1: number): void

setCargobobPickupMagnetPullRopeLength ​

ts
setCargobobPickupMagnetPullRopeLength(vehicle: number, p1: number): void

setCargobobPickupMagnetPullStrength ​

ts
setCargobobPickupMagnetPullStrength(cargobob: number, p1: number): void

setCargobobPickupMagnetReducedFalloff ​

ts
setCargobobPickupMagnetReducedFalloff(cargobob: number, p1: number): void

setCargobobPickupMagnetReducedStrength ​

ts
setCargobobPickupMagnetReducedStrength(cargobob: number, p1: number): void

setCargobobPickupMagnetSetAmbientMode ​

ts
setCargobobPickupMagnetSetAmbientMode(vehicle: number, p1: boolean, p2: boolean): void

setCargobobPickupMagnetSetTargetedMode ​

ts
setCargobobPickupMagnetSetTargetedMode(vehicle: number, cargobob: number): void

setCargobobPickupMagnetStrength ​

ts
setCargobobPickupMagnetStrength(cargobob: number, strength: number): void

setCargobobPickupRopeDampingMultiplier ​

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

setCargobobPickupRopeType ​

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

setCarHighSpeedBumpSeverityMultiplier ​

ts
setCarHighSpeedBumpSeverityMultiplier(multiplier: number): void

setCarjackMissionRemovalParameters ​

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

setCheckForEnoughRoomForPed ​

ts
setCheckForEnoughRoomForPed(vehicle: number, p1: boolean): void

setClearFreezeWaitingOnCollisionOncePlayerEnters ​

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

setConvertibleRoof ​

ts
setConvertibleRoof(vehicle: number, p1: boolean): void

setConvertibleRoofLatchState ​

ts
setConvertibleRoofLatchState(vehicle: number, state: boolean): void

setDeployFoldingWings ​

ts
setDeployFoldingWings(vehicle: number, deploy: boolean, p2: boolean): void

setDipStraightDownWhenCrashingPlane ​

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

setDisableAutomaticCrashTask ​

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

setDisableBmxExtraTrickForces ​

ts
setDisableBmxExtraTrickForces(p0: number): void

setDisableDamageWithPickedUpEntity ​

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

setDisableExplodeFromBodyDamageOnCollision ​

ts
setDisableExplodeFromBodyDamageOnCollision(vehicle: number, disable: boolean): void

setDisableHeliExplodeFromBodyDamage ​

ts
setDisableHeliExplodeFromBodyDamage(vehicle: number, disable: boolean): void

setDisableHoverModeFlight ​

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

setDisableMapCollision ​

ts
setDisableMapCollision(vehicle: number): void

setDisablePedStandOnTop ​

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

setDisablePretendOccupants ​

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

setDisableRandomTrainsThisFrame ​

ts
setDisableRandomTrainsThisFrame(toggle: boolean): void

setDisableRetractingWeaponBlades ​

ts
setDisableRetractingWeaponBlades(toggle: boolean): void

setDisableSuperdummy ​

ts
setDisableSuperdummy(vehicle: number, p1: boolean): void

setDisableTurretMovement ​

ts
setDisableTurretMovement(vehicle: number, turretid: number): void

setDisableVehicleEngineFires ​

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

setDisableVehicleExplosionsDamage ​

ts
setDisableVehicleExplosionsDamage(toggle: boolean): void

setDisableVehiclePetrolTankDamage ​

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

setDisableVehiclePetrolTankFires ​

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

setDisableVerticalFlightModeTransition ​

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

setDisableWantedConesResponse ​

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

setDisableWeaponBladeForces ​

ts
setDisableWeaponBladeForces(toggle: boolean): void

setDistantCarsEnabled ​

ts
setDistantCarsEnabled(toggle: boolean): void

setDontAllowPlayerToEnterVehicleIfLockedForPlayer ​

ts
setDontAllowPlayerToEnterVehicleIfLockedForPlayer(vehicle: number, p1: boolean): void

setDontProcessVehicleGlass ​

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

setDoorAllowedToBeBrokenOff ​

ts
setDoorAllowedToBeBrokenOff(vehicle: number, doorid: number, isbreakable: boolean): void

setDriftTyres ​

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

setEnableVehicleSlipstreaming ​

ts
setEnableVehicleSlipstreaming(toggle: boolean): void

setFarDrawVehicles ​

ts
setFarDrawVehicles(toggle: boolean): void

setFleeingVehiclesUseSwitchedOffNodes ​

ts
setFleeingVehiclesUseSwitchedOffNodes(p0: number): void

setForceFixLinkMatrices ​

ts
setForceFixLinkMatrices(vehicle: number): void

setForceHdVehicle ​

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

setForceLowLodAnchorMode ​

ts
setForceLowLodAnchorMode(vehicle: number, p1: boolean): void

setForceVehicleEngineDamageByBullet ​

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

setForkliftForkHeight ​

ts
setForkliftForkHeight(vehicle: number, height: number): void

setFormationLeader ​

ts
setFormationLeader(vehicle: number, x: number, y: number, z: number, p4: number): void

setGarbageTrucks ​

ts
setGarbageTrucks(toggle: boolean): void

setGliderActive ​

ts
setGliderActive(vehicle: number, state: boolean): void

setGlobalPositionOffsetForRecordedVehiclePlayback ​

ts
setGlobalPositionOffsetForRecordedVehiclePlayback(vehicle: number, x: number, y: number, z: number): void

setGoonBossVehicle ​

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

setGroundEffectReducesDrag ​

ts
setGroundEffectReducesDrag(toggle: boolean): void

setHeliBladesFullSpeed ​

ts
setHeliBladesFullSpeed(vehicle: number): void

setHeliBladesSpeed ​

ts
setHeliBladesSpeed(vehicle: number, speed: number): void

setHeliCanPickupEntityThatHasPickUpDisabled ​

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

setHeliCombatOffset ​

ts
setHeliCombatOffset(vehicle: number, x: number, y: number, z: number): void

setHeliControlLaggingRateScalar ​

ts
setHeliControlLaggingRateScalar(helicopter: number, multiplier: number): void

setHeliMainRotorHealth ​

ts
setHeliMainRotorHealth(vehicle: number, health: number): void

setHeliResistToExplosion ​

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

setHeliTailBoomCanBreakOff ​

ts
setHeliTailBoomCanBreakOff(vehicle: number, toggle: boolean): boolean

setHeliTailRotorHealth ​

ts
setHeliTailRotorHealth(vehicle: number, health: number): void

setHeliTurbulenceScalar ​

ts
setHeliTurbulenceScalar(vehicle: number, p1: number): void

setHoverModeWingRatio ​

ts
setHoverModeWingRatio(vehicle: number, ratio: number): void

setHydraulicsControl ​

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

setHydraulicSuspensionRaiseFactor ​

ts
setHydraulicSuspensionRaiseFactor(vehicle: number, wheelid: number, value: number): void

setHydraulicVehicleState ​

ts
setHydraulicVehicleState(vehicle: number, state: number): void

setHydraulicWheelState ​

ts
setHydraulicWheelState(vehicle: number, wheelid: number, state: number, value: number, p4: number): void

setIgnorePlanesSmallPitchChange ​

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

setIncreaseWheelCrushDamage ​

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

setInvertVehicleControls ​

ts
setInvertVehicleControls(vehicle: number, state: boolean): void

setLastDrivenVehicle ​

ts
setLastDrivenVehicle(vehicle: number): void

setLightsCutoffDistanceTweak ​

ts
setLightsCutoffDistanceTweak(distance: number): void

setMissionTrainAsNoLongerNeeded ​

ts
setMissionTrainAsNoLongerNeeded(p1: boolean): { train: number }

setMissionTrainCoords ​

ts
setMissionTrainCoords(train: number, x: number, y: number, z: number): void

setNitrousIsActive ​

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

setNumberOfParkedVehicles ​

ts
setNumberOfParkedVehicles(value: number): void

setOpenRearDoorsOnExplosion ​

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

setOverrideNitrousLevel ​

ts
setOverrideNitrousLevel(vehicle: number, toggle: boolean, level: number, power: number, rechargetime: number, disablesound: boolean): void

setOverrideVehicleDoorTorque ​

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

setParkedVehicleDensityMultiplierThisFrame ​

ts
setParkedVehicleDensityMultiplierThisFrame(multiplier: number): void

setPedsCanFallOffThisVehicleFromLargeFallDamage ​

ts
setPedsCanFallOffThisVehicleFromLargeFallDamage(vehicle: number, toggle: boolean, p2: number): void

setPickupRopeLengthForCargobob ​

ts
setPickupRopeLengthForCargobob(cargobob: number, length1: number, length2: number, p3: boolean): void

setPickupRopeLengthWithoutCreatingRopeForCargobob ​

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

setPlaneControlSectionsShouldBreakOffFromExplosions ​

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

setPlaneEngineHealth ​

ts
setPlaneEngineHealth(vehicle: number, health: number): void

setPlanePropellerHealth ​

ts
setPlanePropellerHealth(plane: number, health: number): boolean

setPlaneResistToExplosion ​

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

setPlaneSectionDamageScale ​

ts
setPlaneSectionDamageScale(vehicle: number, p1: number, p2: number): void

setPlaneTurbulenceMultiplier ​

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

setPlaybackSpeed ​

ts
setPlaybackSpeed(vehicle: number, speed: number): void

setPlaybackToUseAi ​

ts
setPlaybackToUseAi(vehicle: number, drivingstyle: number): void

setPlaybackToUseAiTryToRevertBackLater ​

ts
setPlaybackToUseAiTryToRevertBackLater(vehicle: number, time: number, drivingstyle: number, p3: boolean): void

setPlayersLastVehicle ​

ts
setPlayersLastVehicle(vehicle: number): void

setPoliceFocusWillTrackVehicle ​

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

setPositionOffsetForRecordedVehiclePlayback ​

ts
setPositionOffsetForRecordedVehiclePlayback(vehicle: number, x: number, y: number, z: number): void

setRandomBoats ​

ts
setRandomBoats(toggle: boolean): void

setRandomBoatsMp ​

ts
setRandomBoatsMp(toggle: boolean): void

setRandomTrains ​

ts
setRandomTrains(toggle: boolean): void

setRandomVehicleDensityMultiplierThisFrame ​

ts
setRandomVehicleDensityMultiplierThisFrame(multiplier: number): void

setReducedSuspensionForce ​

ts
setReducedSuspensionForce(vehicle: number, enable: boolean): void

setRenderTrainAsDerailed ​

ts
setRenderTrainAsDerailed(train: number, toggle: boolean): void

setRocketBoostActive ​

ts
setRocketBoostActive(vehicle: number, active: boolean): void

setRocketBoostFill ​

ts
setRocketBoostFill(vehicle: number, percentage: number): void

setScriptRampImpulseScale ​

ts
setScriptRampImpulseScale(vehicle: number, impulsescale: number): void

setScriptRocketBoostRechargeTime ​

ts
setScriptRocketBoostRechargeTime(vehicle: number, seconds: number): void

setScriptVehicleGenerator ​

ts
setScriptVehicleGenerator(vehiclegenerator: number, enabled: boolean): void

setShortSlowdownForLanding ​

ts
setShortSlowdownForLanding(vehicle: number): void

setShouldLerpFromAiToFullRecording ​

ts
setShouldLerpFromAiToFullRecording(vehicle: number, p1: boolean): void

setShouldResetTurretInScriptedCameras ​

ts
setShouldResetTurretInScriptedCameras(vehicle: number, shouldreset: boolean): void

setSlowDownEffectDisabled ​

ts
setSlowDownEffectDisabled(disabled: boolean): void

setSpecialFlightModeAllowed ​

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

setSpecialFlightModeRatio ​

ts
setSpecialFlightModeRatio(vehicle: number, ratio: number): void

setSpecialFlightModeTargetRatio ​

ts
setSpecialFlightModeTargetRatio(vehicle: number, targetratio: number): void

setSpeedBoostEffectDisabled ​

ts
setSpeedBoostEffectDisabled(disabled: boolean): void

setSubmarineCrushDepths ​

ts
setSubmarineCrushDepths(vehicle: number, p1: boolean, depth1: number, depth2: number, depth3: number): void

setTaskVehicleGotoPlaneMinHeightAboveTerrain ​

ts
setTaskVehicleGotoPlaneMinHeightAboveTerrain(plane: number, height: number): void

setTaxiLights ​

ts
setTaxiLights(vehicle: number, state: boolean): void

setTrailerAttachmentEnabled ​

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

setTrailerInverseMassScale ​

ts
setTrailerInverseMassScale(vehicle: number, p1: number): void

setTrailerLegsLowered ​

ts
setTrailerLegsLowered(vehicle: number): void

setTrailerLegsRaised ​

ts
setTrailerLegsRaised(vehicle: number): void

setTrainCruiseSpeed ​

ts
setTrainCruiseSpeed(train: number, speed: number): void

setTrainSpeed ​

ts
setTrainSpeed(train: number, speed: number): void

setTrainTrackSpawnFrequency ​

ts
setTrainTrackSpawnFrequency(trackindex: number, frequency: number): void

setTransformRateForAnimation ​

ts
setTransformRateForAnimation(vehicle: number, transformrate: number): void

setTransformToSubmarineUsesAlternateInput ​

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

setTurretHidden ​

ts
setTurretHidden(vehicle: number, index: number, toggle: boolean): void

setTyreHealth ​

ts
setTyreHealth(vehicle: number, wheelindex: number, health: number): void

setTyreMaximumGripDifferenceDueToWearRate ​

ts
setTyreMaximumGripDifferenceDueToWearRate(vehicle: number, wheelindex: number, multiplier: number): void

setTyreWearRate ​

ts
setTyreWearRate(vehicle: number, wheelindex: number, multiplier: number): void

setTyreWearRateScale ​

ts
setTyreWearRateScale(vehicle: number, wheelindex: number, multiplier: number): void

setUseDesiredZCruiseSpeedForLanding ​

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

setUseDoubleClickForCarJump ​

ts
setUseDoubleClickForCarJump(toggle: boolean): void

setUseHigherCarJump ​

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

setVehicleActAsIfHasSirenOn ​

ts
setVehicleActAsIfHasSirenOn(vehicle: number, p1: boolean): void

setVehicleActAsIfHighSpeedForFragSmashing ​

ts
setVehicleActAsIfHighSpeedForFragSmashing(vehicle: number, p1: boolean): void

setVehicleActiveDuringPlayback ​

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

setVehicleActiveForPedNavigation ​

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

setVehicleAiCanUseExclusiveSeats ​

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

setVehicleAlarm ​

ts
setVehicleAlarm(vehicle: number, state: boolean): void

setVehicleAllowHomingMissleLockon ​

ts
setVehicleAllowHomingMissleLockon(vehicle: number, toggle: boolean, p2: boolean): void

setVehicleAllowHomingMissleLockonSynced ​

ts
setVehicleAllowHomingMissleLockonSynced(vehicle: number, canbelockedon: boolean, p2: boolean): void

setVehicleAllowNoPassengersLockon ​

ts
setVehicleAllowNoPassengersLockon(veh: number, toggle: boolean): void

setVehicleAutomaticallyAttaches ​

ts
setVehicleAutomaticallyAttaches(vehicle: number, p1: boolean, p2: number): number

setVehicleAvoidPlayerVehicleRiotVanMission ​

ts
setVehicleAvoidPlayerVehicleRiotVanMission(p0: number): void

setVehicleBlipThrottleRandomly ​

ts
setVehicleBlipThrottleRandomly(vehicle: number, p1: boolean): void

setVehicleBobbleheadVelocity ​

ts
setVehicleBobbleheadVelocity(x: number, y: number, p2: number): void

setVehicleBodyHealth ​

ts
setVehicleBodyHealth(vehicle: number, value: number): void

setVehicleBombAmmo ​

ts
setVehicleBombAmmo(vehicle: number, bombcount: number): void

setVehicleBrake ​

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

setVehicleBrakeLights ​

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

setVehicleBrokenPartsDontAffectAiHandling ​

ts
setVehicleBrokenPartsDontAffectAiHandling(vehicle: number, p1: boolean): void

setVehicleBulldozerArmPosition ​

ts
setVehicleBulldozerArmPosition(vehicle: number, position: number, p2: boolean): void

setVehicleBurnout ​

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

setVehicleCanBeTargetted ​

ts
setVehicleCanBeTargetted(vehicle: number, state: boolean): void

setVehicleCanBeUsedByFleeingPeds ​

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

setVehicleCanBeVisiblyDamaged ​

ts
setVehicleCanBeVisiblyDamaged(vehicle: number, state: boolean): void

setVehicleCanBreak ​

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

setVehicleCanDeformWheels ​

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

setVehicleCanEjectPassengersIfLocked ​

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

setVehicleCanEngineMissfire ​

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

setVehicleCanLeakOil ​

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

setVehicleCanLeakPetrol ​

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

setVehicleCanSaveInGarage ​

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

setVehicleCausesSwerving ​

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

setVehicleCeilingHeight ​

ts
setVehicleCeilingHeight(vehicle: number, height: number): void

setVehicleCheatPowerIncrease ​

ts
setVehicleCheatPowerIncrease(vehicle: number, value: number): void

setVehicleColourCombination ​

ts
setVehicleColourCombination(vehicle: number, colorcombination: number): void

setVehicleColours ​

ts
setVehicleColours(vehicle: number, colorprimary: number, colorsecondary: number): void

setVehicleCombatMode ​

ts
setVehicleCombatMode(toggle: boolean): void

setVehicleCountermeasureAmmo ​

ts
setVehicleCountermeasureAmmo(vehicle: number, countermeasurecount: number): void

setVehicleCustomPathNodeStreamingRadius ​

ts
setVehicleCustomPathNodeStreamingRadius(vehicle: number, p1: number): void

setVehicleCustomPrimaryColour ​

ts
setVehicleCustomPrimaryColour(vehicle: number, r: number, g: number, b: number): void

setVehicleCustomSecondaryColour ​

ts
setVehicleCustomSecondaryColour(vehicle: number, r: number, g: number, b: number): void

setVehicleDamage ​

ts
setVehicleDamage(vehicle: number, xoffset: number, yoffset: number, zoffset: number, damage: number, radius: number, focusonmodel: boolean): void

setVehicleDamageScale ​

ts
setVehicleDamageScale(vehicle: number, p1: number): boolean

setVehicleDamageScales ​

ts
setVehicleDamageScales(vehicle: number, p1: number, p2: number, p3: number, p4: number): void

setVehicleDeformationFixed ​

ts
setVehicleDeformationFixed(vehicle: number): void

setVehicleDensityMultiplierThisFrame ​

ts
setVehicleDensityMultiplierThisFrame(multiplier: number): void

setVehicleDetonationMode ​

ts
setVehicleDetonationMode(toggle: boolean): void

setVehicleDirtLevel ​

ts
setVehicleDirtLevel(vehicle: number, dirtlevel: number): void

setVehicleDisableCollisionUponCreation ​

ts
setVehicleDisableCollisionUponCreation(vehicle: number, disable: boolean): void

setVehicleDisableHeightMapAvoidance ​

ts
setVehicleDisableHeightMapAvoidance(vehicle: number, p1: boolean): void

setVehicleDisableTowing ​

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

setVehicleDontTerminateTaskWhenAchieved ​

ts
setVehicleDontTerminateTaskWhenAchieved(vehicle: number): void

setVehicleDoorAutoLock ​

ts
setVehicleDoorAutoLock(vehicle: number, doorid: number, toggle: boolean): void

setVehicleDoorBroken ​

ts
setVehicleDoorBroken(vehicle: number, doorid: number, deletedoor: boolean): void

setVehicleDoorControl ​

ts
setVehicleDoorControl(vehicle: number, doorid: number, speed: number, angle: number): void

setVehicleDoorLatched ​

ts
setVehicleDoorLatched(vehicle: number, doorid: number, p2: boolean, p3: boolean, p4: boolean): void

setVehicleDoorOpen ​

ts
setVehicleDoorOpen(vehicle: number, doorid: number, loose: boolean, openinstantly: boolean): void

setVehicleDoorShut ​

ts
setVehicleDoorShut(vehicle: number, doorid: number, closeinstantly: boolean): void

setVehicleDoorsLocked ​

ts
setVehicleDoorsLocked(vehicle: number, doorlockstatus: number): void

setVehicleDoorsLockedForAllPlayers ​

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

setVehicleDoorsLockedForAllTeams ​

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

setVehicleDoorsLockedForNonScriptPlayers ​

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

setVehicleDoorsLockedForPlayer ​

ts
setVehicleDoorsLockedForPlayer(vehicle: number, player: number, toggle: boolean): void

setVehicleDoorsLockedForTeam ​

ts
setVehicleDoorsLockedForTeam(vehicle: number, team: number, toggle: boolean): void

setVehicleDoorsShut ​

ts
setVehicleDoorsShut(vehicle: number, closeinstantly: boolean): void

setVehicleDropsMoneyWhenBlownUp ​

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

setVehicleEngineCanDegrade ​

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

setVehicleEngineHealth ​

ts
setVehicleEngineHealth(vehicle: number, health: number): void

setVehicleEngineOn ​

ts
setVehicleEngineOn(vehicle: number, value: boolean, instantly: boolean, disableautostart: boolean): void

setVehicleEnveffScale ​

ts
setVehicleEnveffScale(vehicle: number, fade: number): void

setVehicleExclusiveDriver ​

ts
setVehicleExclusiveDriver(vehicle: number, ped: number, index: number): void

setVehicleExplodesOnExplosionDamageAtZeroBodyHealth ​

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

setVehicleExplodesOnHighExplosionDamage ​

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

setVehicleExtendedRemovalRange ​

ts
setVehicleExtendedRemovalRange(vehicle: number, range: number): void

setVehicleExtra ​

ts
setVehicleExtra(vehicle: number, extraid: number, disable: boolean): void

setVehicleExtraColour5 ​

ts
setVehicleExtraColour5(vehicle: number, color: number): void

setVehicleExtraColour6 ​

ts
setVehicleExtraColour6(vehicle: number, color: number): void

setVehicleExtraColours ​

ts
setVehicleExtraColours(vehicle: number, pearlescentcolor: number, wheelcolor: number): void

setVehicleFixed ​

ts
setVehicleFixed(vehicle: number): void

setVehicleFlightNozzlePosition ​

ts
setVehicleFlightNozzlePosition(vehicle: number, angleratio: number): void

setVehicleFlightNozzlePositionImmediate ​

ts
setVehicleFlightNozzlePositionImmediate(vehicle: number, angle: number): void

setVehicleForceAfterburner ​

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

setVehicleForceInteriorlight ​

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

setVehicleForwardSpeed ​

ts
setVehicleForwardSpeed(vehicle: number, speed: number): void

setVehicleForwardSpeedXy ​

ts
setVehicleForwardSpeedXy(vehicle: number, speed: number): void

setVehicleFrictionOverride ​

ts
setVehicleFrictionOverride(vehicle: number, friction: number): void

setVehicleFullbeam ​

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

setVehicleGeneratesEngineShockingEvents ​

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

setVehicleGeneratorAreaOfInterest ​

ts
setVehicleGeneratorAreaOfInterest(x: number, y: number, z: number, radius: number): void

setVehicleGravity ​

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

setVehicleHandbrake ​

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

setVehicleHandlingOverride ​

ts
setVehicleHandlingOverride(vehicle: number, hash: number): void

setVehicleHasBeenDrivenFlag ​

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

setVehicleHasBeenOwnedByPlayer ​

ts
setVehicleHasBeenOwnedByPlayer(vehicle: number, owned: boolean): void

setVehicleHasMutedSirens ​

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

setVehicleHasStrongAxles ​

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

setVehicleHasUnbreakableLights ​

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

setVehicleHeadlightShadows ​

ts
setVehicleHeadlightShadows(vehicle: number, p1: number): void

setVehicleHomingLockedontoState ​

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

setVehicleImpatienceTimer ​

ts
setVehicleImpatienceTimer(vehicle: number, p1: number): void

setVehicleInactiveDuringPlayback ​

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

setVehicleInCarModShop ​

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

setVehicleIndicatorLights ​

ts
setVehicleIndicatorLights(vehicle: number, turnsignal: number, toggle: boolean): void

setVehicleIndividualDoorsLocked ​

ts
setVehicleIndividualDoorsLocked(vehicle: number, doorid: number, doorlockstatus: number): void

setVehicleInfluencesWantedLevel ​

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

setVehicleInteriorlight ​

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

setVehicleIsConsideredByPlayer ​

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

setVehicleIsRacing ​

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

setVehicleIsStolen ​

ts
setVehicleIsStolen(vehicle: number, isstolen: boolean): void

setVehicleIsWanted ​

ts
setVehicleIsWanted(vehicle: number, state: boolean): void

setVehicleKeepEngineOnWhenAbandoned ​

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

setVehicleKersAllowed ​

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

setVehicleLightMultiplier ​

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

setVehicleLights ​

ts
setVehicleLights(vehicle: number, state: number): void

setVehicleLimitSpeedWhenPlayerInactive ​

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

setVehicleLivery ​

ts
setVehicleLivery(vehicle: number, livery: number): void

setVehicleLivery2 ​

ts
setVehicleLivery2(vehicle: number, livery: number): void

setVehicleLodMultiplier ​

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

setVehicleMaxSpeed ​

ts
setVehicleMaxSpeed(vehicle: number, speed: number): void

setVehicleMayBeUsedByGotoPointAnyMeans ​

ts
setVehicleMayBeUsedByGotoPointAnyMeans(vehicle: number, p1: boolean): void

setVehicleMod ​

ts
setVehicleMod(vehicle: number, modtype: number, modindex: number, customtires: boolean): void

setVehicleModColor1 ​

ts
setVehicleModColor1(vehicle: number, painttype: number, color: number, pearlescentcolor: number): void

setVehicleModColor2 ​

ts
setVehicleModColor2(vehicle: number, painttype: number, color: number): void

setVehicleModelIsSuppressed ​

ts
setVehicleModelIsSuppressed(model: number, suppressed: boolean): void

setVehicleModKit ​

ts
setVehicleModKit(vehicle: number, modkit: number): void

setVehicleNameDebug ​

ts
setVehicleNameDebug(vehicle: number, name: string): void

setVehicleNeedsToBeHotwired ​

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

setVehicleNeonColour ​

ts
setVehicleNeonColour(vehicle: number, r: number, g: number, b: number): void

setVehicleNeonEnabled ​

ts
setVehicleNeonEnabled(vehicle: number, index: number, toggle: boolean): void

setVehicleNeonIndexColour ​

ts
setVehicleNeonIndexColour(vehicle: number, index: number): void

setVehicleNoExplosionDamageFromDriver ​

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

setVehicleNotStealableAmbiently ​

ts
setVehicleNotStealableAmbiently(vehicle: number, p1: boolean): void

setVehicleNumberPlateText ​

ts
setVehicleNumberPlateText(vehicle: number, platetext: string): void

setVehicleNumberPlateTextIndex ​

ts
setVehicleNumberPlateTextIndex(vehicle: number, plateindex: number): void

setVehicleOccupantsTakeExplosiveDamage ​

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

setVehicleOnGroundProperly ​

ts
setVehicleOnGroundProperly(vehicle: number, p1: number): boolean

setVehicleOutOfControl ​

ts
setVehicleOutOfControl(vehicle: number, killdriver: boolean, explodeonimpact: boolean): void

setVehiclePetrolTankHealth ​

ts
setVehiclePetrolTankHealth(vehicle: number, health: number): void

setVehicleProvidesCover ​

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

setVehicleReadyForCleanup ​

ts
setVehicleReadyForCleanup(p0: number): void

setVehicleReduceGrip ​

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

setVehicleReduceGripLevel ​

ts
setVehicleReduceGripLevel(vehicle: number, val: number): void

setVehicleRemoveAggressiveCarjackMission ​

ts
setVehicleRemoveAggressiveCarjackMission(p0: number): void

setVehicleRespectsLocksWhenHasDriver ​

ts
setVehicleRespectsLocksWhenHasDriver(vehicle: number, p1: boolean): void

setVehicleRudderBroken ​

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

setVehicleSearchlight ​

ts
setVehicleSearchlight(heli: number, toggle: boolean, canbeusedbyai: boolean): void

setVehicleShootAtTarget ​

ts
setVehicleShootAtTarget(driver: number, entity: number, xtarget: number, ytarget: number, ztarget: number): void

setVehicleShuntOnStick ​

ts
setVehicleShuntOnStick(toggle: boolean): void

setVehicleSiren ​

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

setVehicleSlipstreamingShouldTimeOut ​

ts
setVehicleSlipstreamingShouldTimeOut(toggle: boolean): void

setVehicleStaysFrozenWhenCleanedUp ​

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

setVehicleSteerBias ​

ts
setVehicleSteerBias(vehicle: number, value: number): void

setVehicleSteerForBuildings ​

ts
setVehicleSteerForBuildings(vehicle: number, p1: number): void

setVehicleSteeringBiasScalar ​

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

setVehicleStopInstantlyWhenPlayerInactive ​

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

setVehicleStrong ​

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

setVehicleTailLights ​

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

setVehicleTankStationary ​

ts
setVehicleTankStationary(vehicle: number, p1: boolean): void

setVehicleTankTurretPosition ​

ts
setVehicleTankTurretPosition(vehicle: number, position: number, p2: boolean): void

setVehicleTimedExplosion ​

ts
setVehicleTimedExplosion(vehicle: number, ped: number, toggle: boolean): void

setVehicleTowTruckArmPosition ​

ts
setVehicleTowTruckArmPosition(vehicle: number, position: number): void

setVehicleTurretSpeedThisFrame ​

ts
setVehicleTurretSpeedThisFrame(vehicle: number, speed: number): void

setVehicleTurretTarget ​

ts
setVehicleTurretTarget(vehicle: number, p1: boolean, x: number, y: number, z: number, p5: boolean): void

setVehicleTyreBurst ​

ts
setVehicleTyreBurst(vehicle: number, index: number, onrim: boolean, p3: number): void

setVehicleTyreFixed ​

ts
setVehicleTyreFixed(vehicle: number, tyreindex: number): void

setVehicleTyresCanBurst ​

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

setVehicleTyreSmokeColor ​

ts
setVehicleTyreSmokeColor(vehicle: number, r: number, g: number, b: number): void

setVehicleUndriveable ​

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

setVehicleUseAlternateHandling ​

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

setVehicleUseBoostButtonForWheelRetract ​

ts
setVehicleUseBoostButtonForWheelRetract(toggle: boolean): void

setVehicleUseCutsceneWheelCompression ​

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

setVehicleUsedForPilotSchool ​

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

setVehicleUseMoreRestrictiveSpawnChecks ​

ts
setVehicleUseMoreRestrictiveSpawnChecks(vehicle: number, p1: boolean): void

setVehicleUsePlayerLightSettings ​

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

setVehicleUsesLargeRearRamp ​

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

setVehicleUsesMpPlayerDamageMultiplier ​

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

setVehicleWeaponCanTargetObjects ​

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

setVehicleWeaponDamageScale ​

ts
setVehicleWeaponDamageScale(vehicle: number, multiplier: number): boolean

setVehicleWeaponRestrictedAmmo ​

ts
setVehicleWeaponRestrictedAmmo(vehicle: number, weaponindex: number, capacity: number): void

setVehicleWheelsCanBreak ​

ts
setVehicleWheelsCanBreak(vehicle: number, enabled: boolean): void

setVehicleWheelsCanBreakOffWhenBlowUp ​

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

setVehicleWheelType ​

ts
setVehicleWheelType(vehicle: number, wheeltype: number): void

setVehicleWillForceOtherVehiclesToStop ​

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

setVehicleWillTellOthersToHurry ​

ts
setVehicleWillTellOthersToHurry(vehicle: number, p1: boolean): void

setVehicleWindowTint ​

ts
setVehicleWindowTint(vehicle: number, tint: number): void

setVehicleXenonLightColorIndex ​

ts
setVehicleXenonLightColorIndex(vehicle: number, colorindex: number): void

setWheelieEnabled ​

ts
setWheelieEnabled(vehicle: number, enabled: boolean): void

setWheelsExtendedInstantly ​

ts
setWheelsExtendedInstantly(vehicle: number): void

setWheelsRetractedInstantly ​

ts
setWheelsRetractedInstantly(vehicle: number): void

skipTimeInPlaybackRecordedVehicle ​

ts
skipTimeInPlaybackRecordedVehicle(vehicle: number, time: number): void

skipToEndAndStopPlaybackRecordedVehicle ​

ts
skipToEndAndStopPlaybackRecordedVehicle(vehicle: number): void

smashVehicleWindow ​

ts
smashVehicleWindow(vehicle: number, windowindex: number): void

stabiliseEntityAttachedToHeli ​

ts
stabiliseEntityAttachedToHeli(vehicle: number, entity: number, p2: number): void

startPlaybackRecordedVehicle ​

ts
startPlaybackRecordedVehicle(vehicle: number, recording: number, script: string, p3: boolean): void

startPlaybackRecordedVehicleUsingAi ​

ts
startPlaybackRecordedVehicleUsingAi(vehicle: number, recording: number, script: string, speed: number, drivingstyle: number): void

startPlaybackRecordedVehicleWithFlags ​

ts
startPlaybackRecordedVehicleWithFlags(vehicle: number, recording: number, script: string, flags: number, time: number, drivingstyle: number): void

startVehicleAlarm ​

ts
startVehicleAlarm(vehicle: number): void

startVehicleHorn ​

ts
startVehicleHorn(vehicle: number, duration: number, mode: number, forever: boolean): void

stopAllGarageActivity ​

ts
stopAllGarageActivity(): void

stopBringingVehicleToHalt ​

ts
stopBringingVehicleToHalt(vehicle: number): void

stopPlaybackRecordedVehicle ​

ts
stopPlaybackRecordedVehicle(vehicle: number): void

suppressNeonsOnVehicle ​

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

swingBoatBoomFreely ​

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

swingBoatBoomToRatio ​

ts
swingBoatBoomToRatio(vehicle: number, ratio: number): void

switchTrainTrack ​

ts
switchTrainTrack(trackid: number, state: boolean): void

toggleVehicleMod ​

ts
toggleVehicleMod(vehicle: number, modtype: number, toggle: boolean): void

trackVehicleVisibility ​

ts
trackVehicleVisibility(vehicle: number): void

transformToCar ​

ts
transformToCar(vehicle: number, noanimation: boolean): void

transformToSubmarine ​

ts
transformToSubmarine(vehicle: number, noanimation: boolean): boolean

unpausePlaybackRecordedVehicle ​

ts
unpausePlaybackRecordedVehicle(vehicle: number): void

vehicleSetEnableNormaliseRampCarVerticalVeloctiy ​

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

vehicleSetEnableRampCarSideImpulse ​

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

vehicleSetExtenableSideTargetRatio ​

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

vehicleSetJetWashForceEnabled ​

ts
vehicleSetJetWashForceEnabled(p0: number): void

vehicleSetOverrideExtenableSideRatio ​

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

vehicleSetOverrideSideRatio ​

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

vehicleSetParachuteModelOverride ​

ts
vehicleSetParachuteModelOverride(vehicle: number, modelhash: number): void

vehicleSetParachuteModelTintIndex ​

ts
vehicleSetParachuteModelTintIndex(vehicle: number, texturevariation: number): void

vehicleSetRampAndRammingCarsTakeDamage ​

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

vehicleStartParachuting ​

ts
vehicleStartParachuting(vehicle: number, active: boolean): void

VIMP developer documentation

Released under the MIT License.