rps_lib — Full Integration Guide¶

local RPS_Lib = exports['rps_lib']:GetLibObject()

framework/
├── esx/   client.lua   server.lua   events.lua
├── qb/    client.lua   server.lua   events.lua
├── qbx/   client.lua   server.lua   events.lua
├── client/init.lua   ← loader: detects framework, merges in the right folder
└── server/init.lua   ← loader: same, server side

exports {
    'GetLibObject',  -- returns the whole _Lib table
    'GetFramework',  -- returns _Lib.Framework as a string
    'GetVersion',    -- returns the RPS.Version string, e.g. '2.0.0'
}

server_exports {
    'GetLibObject',
    'GetFramework',
    'GetVersion',
}

-- Any of these work, client or server:
local RPS_Lib = exports['rps_lib']:GetLibObject()
local fw      = exports['rps_lib']:GetFramework()   -- 'esx' | 'qb' | 'qbx' | 'unknown'
local ver     = exports['rps_lib']:GetVersion()     -- '2.0.0'

-- your_script/fxmanifest.lua
fx_version 'cerulean'
game 'gta5'

dependency 'rps_lib'

client_script 'client.lua'
server_script 'server.lua'

# server.cfg
ensure rps_lib
ensure your_script

local RPS_Lib = exports['rps_lib']:GetLibObject()
print(RPS_Lib.Framework) -- never nil

local RPS_Lib

CreateThread(function()
    while GetResourceState('rps_lib') ~= 'started' do
        Wait(100)
    end
    RPS_Lib = exports['rps_lib']:GetLibObject()
end)

--- @param key string|nil  (Optional, ESX only) specific config key
--- @return table|any

--- @return table

--- @return table { name, label, payment, isboss, grade = { name, level } }

local job = RPS_Lib.GetJob()
if job.name == 'police' and job.isboss then
    -- boss menu access
end

--- @return string

--- @return string

--- @param targetServerId number
--- @param metaKey string
--- @return any

--- @param amount number

--- @param source number
--- @return table|nil

--- @param source number
--- @return string

--- @param source number
--- @return string

--- @param source number
--- @return string

--- @param source number
--- @return string

--- @param source number
--- @param idtype string  e.g. 'steam', 'license', 'discord', 'fivem'
--- @return string|nil

--- @param identifier string
--- @return number|nil

--- @param identifier string
--- @return table|nil

--- @param Player table  a framework player object (from GetPlayer)
--- @return number

--- @param identifier string
--- @return string

--- @param source number
--- @param key string
--- @return any
RPS_Lib.GetMetaData(source, key)

--- @param source number
--- @param key string
--- @param value any
RPS_Lib.SetMetaData(source, key, value)

--- @param identifier string
--- @param key string
--- @return any
RPS_Lib.GetOfflineMetaData(identifier, key)

--- @param identifier string
--- @param key string
--- @param value any
RPS_Lib.SetOfflineMetaData(identifier, key, value)

--- @param source number
--- @return boolean

--- @param source number
--- @param group string
--- @return boolean

--- @param source number
--- @param Admin table  { WithAce, WithLicense, WithIdentifier, WithGroup }
--- @param notify boolean|nil  log which check passed via RPS.Info
--- @return boolean

local allowed = RPS_Lib.HasPermission(source, {
    WithAce   = true,
    WithGroup = { admin = true, god = true },
}, true) -- true = print which check passed

if not allowed then return end

--- @param source number
--- @return table { name, label, payment, isboss, grade = { name, level } }
RPS_Lib.GetJob(source)

--- @param source number
--- @param jobName string
--- @param grade number
RPS_Lib.SetJob(source, jobName, grade)

--- @param source number
--- @return table { name, label, isboss, grade = { name, level } }
RPS_Lib.GetGang(source)

--- @param source number
--- @param gangName string
--- @param grade number
RPS_Lib.SetGang(source, gangName, grade)

--- @return table

--- @param source number
--- @param account string  'cash' | 'money' | 'bank' | 'black_money' | 'crypto'
---                        ('cash' and 'money' are interchangeable — both
---                        map to whichever name the active framework uses)
--- @return number
RPS_Lib.GetMoney(source, account)

--- @param source number
--- @param account string
--- @param amount number
RPS_Lib.AddMoney(source, account, amount)
RPS_Lib.RemoveMoney(source, account, amount)

--- @param identifier string
--- @param account string  'cash' | 'money' | 'bank'
--- @return number
RPS_Lib.GetOfflineMoney(identifier, account)

--- @param identifier string
--- @param account string
--- @param amount number
RPS_Lib.AddOfflineMoney(identifier, account, amount)
RPS_Lib.RemoveOfflineMoney(identifier, account, amount)  -- just calls AddOfflineMoney with -amount

--- @return table

--- @param source number
--- @param plate string
--- @return boolean

--- @param plate string
--- @return string|nil

--- @param format string|nil  Default 'AAAA 11A' — 'A' = random letter, '1' = random digit, anything else is literal
--- @param prefix string|nil
--- @return string  uppercased, truncated to 8 characters

RPS_Lib.GeneratePlate()                  -- e.g. "XQRT 42B"
RPS_Lib.GeneratePlate('11-AAA-11')       -- e.g. "84-QRT-91"
RPS_Lib.GeneratePlate('AAA1111', 'PD')   -- prefix is prepended before the pattern is applied

--- @param source number
--- @param model string|number  model name or hash

--- Populates _Lib.Items / _Lib.ItemsByHash. Called automatically on
--- startup — you don't need to call this yourself.
--- @return nil
RPS_Lib.FetchItems()

--- @param hash number  result of GetHashKey(itemName)
--- @return string|nil
RPS_Lib.GetWeaponNameFromHash(hash)

--- @return string|nil  NUI base path for item images
RPS_Lib.GetInventoryImageLink()

--- @param name string
--- @param format string|nil  defaults to '.png'
--- @return string|nil
RPS_Lib.GetItemImageLink(name, format)

--- @param identifier string  unique stash ID
--- @param name string        display label
--- @param weight number      max weight (kg)
--- @param slots number
RPS_Lib.OpenStash(identifier, name, weight, slots)

--- @param targetServerId number  search/rob another player's inventory
RPS_Lib.OpenSearchInventory(targetServerId)

--- Closes whatever inventory UI is currently open
RPS_Lib.CloseInventory()

--- @param state boolean  lock/unlock the inventory during an action
RPS_Lib.SetInventoryBusy(state)

--- @param item string
--- @param amount number  durability reduction — ak47_inventory only, no-op elsewhere
RPS_Lib.RemoveItemQuality(item, amount)

--- Registers item-remove net events for the active inventory/framework.
--- Called automatically on startup.
RPS_Lib.RegisterInventoryEvents()

--- @param itemName string
--- @param metadata table|nil
--- @param strict boolean|nil
--- @return number
RPS_Lib.GetItemCount(itemName, metadata, strict)

--- @return table  full player inventory contents
RPS_Lib.GetPlayerItems()

--- @return number
RPS_Lib.GetPlayerWeight()

--- @return number
RPS_Lib.GetPlayerMaxWeight()

--- @param search string  'slots' | 'count'
--- @param item string|table
--- @param metadata table|string|nil
--- @return table|number
RPS_Lib.Search(search, item, metadata)

--- @param itemName string
--- @param metadata table|nil
--- @param strict boolean|nil
--- @return number|nil
RPS_Lib.GetSlotIdWithItem(itemName, metadata, strict)

--- @return table|nil  all matching slot ids
RPS_Lib.GetSlotIdsWithItem(itemName, metadata, strict)

--- @return table|nil  single matching slot data
RPS_Lib.GetSlotWithItem(itemName, metadata, strict)

--- @return table|nil  all matching slot data
RPS_Lib.GetSlotsWithItem(itemName, metadata, strict)

--- @return table|nil
RPS_Lib.GetCurrentWeapon()

--- @param data table  item data from an item-use callback
--- @param cb function|nil
RPS_Lib.UseItem(data, cb)

--- @param slot number
RPS_Lib.UseSlot(slot)

--- @param id string|number
--- @param owner string|number|nil
RPS_Lib.SetStashTarget(id, owner)

--- @param metadata string|table
--- @param value string|nil
RPS_Lib.DisplayMetadata(metadata, value)

--- @param serverId number  give an item to another player
--- @param slotId number
--- @param count number|nil
RPS_Lib.GiveItemToTarget(serverId, slotId, count)

--- @param state boolean  enable weapon wheel while disabling inventory weapons
RPS_Lib.WeaponWheel(state)

--- @param value boolean
RPS_Lib.SuppressItemNotifications(value)

--- @return boolean
RPS_Lib.IsInventoryBusy()

--- @return boolean
RPS_Lib.IsInventoryOpen()

-- Example: check before letting a player start an animation that needs both hands free
if RPS_Lib.GetCurrentWeapon() then
    RPS_Lib.Notify("Holster your weapon first.", "error")
    return
end

--- Populates _Lib.Items / _Lib.ItemsByHash. Runs automatically on startup
--- via the inventory auto-detect thread.
RPS_Lib.FetchItems()

--- @return table  master item definitions for the active inventory
RPS_Lib.GetItems()

--- @param item string
--- @return string  label, or the item name itself if not found
RPS_Lib.GetItemLabel(item)

--- @param hash number
--- @return string|nil
RPS_Lib.GetWeaponNameFromHash(hash)

--- @param inventoryId number|string  player source OR stash identifier
--- @param item string
--- @param amount number
--- @param slot number|nil
--- @param meta table|nil
--- @return boolean
RPS_Lib.AddItem(inventoryId, item, amount, slot, meta)
RPS_Lib.RemoveItem(inventoryId, item, amount, slot, meta)

--- @param inventoryId number|string
--- @return table  every item currently in that inventory
RPS_Lib.GetInventoryItems(inventoryId)

--- @param inventoryId number|string
--- @param item string
--- @param metadata table|nil
--- @return number  count of that item
RPS_Lib.GetInventoryItem(inventoryId, item, metadata)

--- @param inventoryId number|string
--- @param item string
--- @param amount number
--- @return boolean
RPS_Lib.HasEnoughItem(inventoryId, item, amount)

--- @param inventoryId number|string
--- @param item string
--- @param amount number
--- @param metadata table|nil
--- @return boolean  whether the inventory has room for this item+amount
RPS_Lib.CanCarryItem(inventoryId, item, amount, metadata)

RegisterNetEvent('your_script:buyItem', function(item, amount)
    local src = source
    if not RPS_Lib.CanCarryItem(src, item, amount) then
        RPS_Lib.Notify(src, "You don't have enough space.", "error")
        return
    end
    RPS_Lib.AddItem(src, item, amount)
end)

--- @return number
RPS_Lib.CanCarryAmount(inventoryId, item)

--- @return boolean, number  can carry, free weight
RPS_Lib.CanCarryWeight(inventoryId, weight)

RPS_Lib.SetMaxWeight(inventoryId, maxWeight)
RPS_Lib.SetSlotCount(inventoryId, slots)

--- @return table|nil
RPS_Lib.GetSlot(inventoryId, slot)

--- @return number|nil
RPS_Lib.GetSlotForItem(inventoryId, itemName, metadata)
RPS_Lib.GetSlotIdWithItem(inventoryId, itemName, metadata, strict)

--- @return table|nil
RPS_Lib.GetSlotIdsWithItem(inventoryId, itemName, metadata, strict)
RPS_Lib.GetSlotWithItem(inventoryId, itemName, metadata, strict)
RPS_Lib.GetSlotsWithItem(inventoryId, itemName, metadata, strict)

--- @return number|nil
RPS_Lib.GetEmptySlot(inventoryId)

--- @return number, number, number  used slots, total count, remaining
RPS_Lib.GetItemSlots(inventoryId, item, metadata)

--- @return table|number
RPS_Lib.Search(inventoryId, search, item, metadata)

--- @return table|nil  full inventory object
RPS_Lib.GetInventory(inventoryId, owner)

--- @param id string|number
--- @param label string
--- @param slots number
--- @param maxWeight number
--- @param owner string|boolean|nil
--- @param groups table|nil
--- @param coords vector3|nil
RPS_Lib.RegisterStash(id, label, slots, maxWeight, owner, groups, coords)

--- @param properties table
--- @return string|nil  inventoryId of the new temp stash
RPS_Lib.CreateTemporaryStash(properties)

--- @param prefix string
--- @param items table
--- @param coords vector3
--- @param slots number|nil
--- @param maxWeight number|nil
--- @param instance string|number|nil
--- @param model number|nil
RPS_Lib.CustomDrop(prefix, items, coords, slots, maxWeight, instance, model)

--- @param playerId number
--- @return string|nil  dropId created from the player's inventory contents
RPS_Lib.CreateDropFromPlayer(playerId)

--- @param keep string|string[]|nil  items to preserve
RPS_Lib.ClearInventory(inventoryId, keep)
RPS_Lib.RemoveInventory(inventoryId)

--- @param source number  confiscate into a stash / return it later
RPS_Lib.ConfiscateInventory(source)
RPS_Lib.ReturnInventory(source)

--- @param target number
--- @param source number  let `source` inspect `target`'s inventory read-only
RPS_Lib.InspectInventory(target, source)

--- @param playerId number
--- @param invType string  'player'|'stash'|'container'|'drop'|'glovebox'|'trunk'|'dumpster'
--- @param data number|string|table
RPS_Lib.ForceOpenInventory(playerId, invType, data)

--- @return table|nil
RPS_Lib.GetCurrentWeapon(inventoryId)

RPS_Lib.SetDurability(inventoryId, slot, durability)
RPS_Lib.SetMetadata(inventoryId, slot, metadata)
RPS_Lib.UpdateVehicle(oldPlate, newPlate)

--- @return boolean
RPS_Lib.CanSwapItem(inventoryId, firstItem, firstItemCount, testItem, testItemCount)

--- @return table|nil
RPS_Lib.GetContainerFromSlot(inventoryId, slotId)

--- @param properties table  { slots, maxWeight, whitelist?, blacklist? }
RPS_Lib.SetContainerProperties(itemName, properties)

--- @param player table  { source, identifier, name, groups?, sex?, dateofbirth? }
--- @param data table|nil
RPS_Lib.SetPlayerInventory(player, data)

--- @param item string
--- @param cb function(source, itemData)
RPS_Lib.CreateUseableItem(item, cb)

RPS_Lib.CreateUseableItem('bandage', function(source, itemData)
    RPS_Lib.RemoveItem(source, 'bandage', 1)
    -- heal logic
end)

--- @param plate string
--- @param vehicle number  entity handle
--- @param virtual boolean|nil  temporary/virtual keys, where supported
RPS_Lib.GiveVehicleKey(plate, vehicle, virtual)
RPS_Lib.RemoveVehicleKey(plate, vehicle, virtual)

--- @param vehicleOrPlate number|string
--- @return boolean
RPS_Lib.HaveVehicleKey(vehicleOrPlate)

--- @param vehicle number
--- @return boolean
RPS_Lib.IsKeyInIgnition(vehicle)

--- @param vehicle number
--- @param state boolean  true = insert, false = remove
RPS_Lib.SetKeyInIgnition(vehicle, state)

--- @param vehicle number|nil
--- @param plate string|nil  use one or the other — restores ignition state on spawn
RPS_Lib.CheckKeyInIgnitionWhenSpawn(vehicle, plate)

--- @param vehicle number
--- @param state boolean  true = lock key in (can't be removed), false = allow removal
RPS_Lib.SetNonRemoveableIgnition(vehicle, state)

--- @param vehicle number
--- @param status number  eVehicleLockState enum (0-10) — falls back to
---                        SetVehicleDoorsLocked on non-tgiann-hotwire systems
RPS_Lib.SetVehicleLockStatus(vehicle, status)

--- @param state boolean|nil  nil = toggle based on current engine state
RPS_Lib.ChangeEngineStateButton(state)

--- @param source number
--- @param plate string
--- @param vehNetId number
--- @param virtual boolean|nil
RPS_Lib.GiveVehicleKey(source, plate, vehNetId, virtual)
RPS_Lib.RemoveVehicleKey(source, plate, vehNetId, virtual)

--- @param vehNetId number|nil
--- @param entity number|nil  use one or the other
--- @return boolean
RPS_Lib.IsKeyInIgnition(vehNetId, entity)

--- @param state boolean
RPS_Lib.SetKeyInIgnition(vehNetId, entity, state)

RPS_Lib.CheckKeyInIgnitionWhenSpawn(vehNetId, entity)

--- @param state boolean
RPS_Lib.SetNonRemoveableIgnition(vehNetId, entity, state)

--- @param vehicle number  entity handle
--- @return number  0-100
RPS_Lib.GetVehicleFuel(vehicle)

--- @param vehicle number
--- @param amount number  0.0 - 100.0
RPS_Lib.SetVehicleFuel(vehicle, amount)

--- @param vehicle number
--- @param fuelType string|nil  'regular' | 'plus' | 'premium' | 'diesel' | nil (reset)
RPS_Lib.SetVehicleFuelType(vehicle, fuelType)  -- lc_fuel only, no-op elsewhere

--- @param garageId string
--- @param vehicle number  entity handle
--- @param garageVehicleType string|nil  'car' | 'sea' | 'air' (jg-advancedgarages only)
RPS_Lib.StoreVehicleHousing(garageId, vehicle, garageVehicleType)

--- @param garageId string
--- @param vehicleType string|nil  'car' | 'air' | 'sea' (jg-advancedgarages only)
--- @param spawnCoords vector4|nil  jg-advancedgarages only
RPS_Lib.OpenGarageHousing(garageId, vehicleType, spawnCoords)

RPS_Lib.ShowImpoundForm()                 -- opens the impound UI, if permitted
RPS_Lib.ShowPrivateGaragesDashboard()     -- create/edit/delete private garages
RPS_Lib.ShowChangePlateForm(vehicle)      -- @param vehicle number|nil

--- @return table  every registered garage's config (jg-advancedgarages only, else {})
RPS_Lib.GetAllGarages()

--- @param plate string
--- @param netId number  vehicle network ID — prevents duplication when
---                       another script also spawns from the same garage.
---                       jg-advancedgarages v3.2.5+ only.
RPS_Lib.RegisterVehicleOutside(plate, netId)

--- @param plate string  deletes a vehicle registered as outside the garage
RPS_Lib.DeleteOutsideVehicle(plate)

--- @param name string
--- @param center vector3
--- @param length number
--- @param width number
--- @param options table     { minZ?, maxZ?, heading?, debugPoly? }
--- @param targetOptions table  { options = {...}, distance = number }
--- @return any  zone id
RPS_Lib.AddBoxZone(name, center, length, width, options, targetOptions)

--- @param points table  array of vector3
--- @param options table  { minZ, maxZ, debugPoly }
--- @return any
RPS_Lib.AddPolyZone(name, points, options, targetOptions)

--- @param center vector3
--- @param radius number
--- @return any
RPS_Lib.AddCircleZone(name, center, radius, options, targetOptions)

--- @param id any  zone id returned by one of the Add*Zone functions
RPS_Lib.RemoveZone(id)

--- @param bones string|table
RPS_Lib.AddTargetBone(bones, targetOptions)

--- @param entities table|number
RPS_Lib.AddTargetEntity(entities, targetOptions)
RPS_Lib.RemoveTargetEntity(entities, labels)

--- @param models string|number|table
RPS_Lib.AddTargetModel(models, targetOptions)
RPS_Lib.RemoveTargetModel(models, labels)

RPS_Lib.AddGlobalPed(targetOptions)
RPS_Lib.RemoveGlobalPed(labels)

RPS_Lib.AddGlobalVehicle(targetOptions)
RPS_Lib.RemoveGlobalVehicle(labels)

RPS_Lib.AddGlobalObject(targetOptions)
RPS_Lib.RemoveGlobalObject(labels)

RPS_Lib.AddGlobalPlayer(targetOptions)
RPS_Lib.RemoveGlobalPlayer(labels)

RPS_Lib.AddBoxZone('shop_zone', vector3(100.0, 200.0, 30.0), 2.0, 2.0, {
    heading = 0.0,
}, {
    options = {
        {
            label  = 'Open Shop',
            icon   = 'fas fa-shopping-cart',
            job    = 'unemployed',  -- works as a single job string...
            action = function() TriggerEvent('your_script:openShop') end,
        },
    },
    distance = 2.5,
})

--- @param msg string
--- @param ntype string  'success' | 'error' | 'info'
--- @param duration number|nil  ms, defaults to 5000

--- @param data table  { label, duration, useWhileDead?, canCancel?, disable?, anim?, prop? }
--- @param successCb function|nil  called if the bar completes
--- @param cancelCb function|nil   called if the bar is cancelled
--- @return boolean  true = completed, false = cancelled

local completed = RPS_Lib.ShowProgress({
    label     = 'Repairing engine...',
    duration  = 5000,
    canCancel = true,
    disable   = { move = true, car = true, combat = true },
}, function()
    RPS_Lib.Notify('Repair complete.', 'success')
end, function()
    RPS_Lib.Notify('Repair cancelled.', 'error')
end)

--- @param target number|nil  server ID of another player, or nil for self
--- @return boolean
RPS_Lib.IsDead(target)
RPS_Lib.IsLastStand(target)

--- @return boolean  IsDead(target) or IsLastStand(target)
RPS_Lib.IsIncapacitated(target)

--- @param amount number
RPS_Lib.AddStress(amount)
RPS_Lib.RemoveStress(amount)

-- Client
--- @return number  0-100
RPS_Lib.GetStress()

--- @param amount number
RPS_Lib.GainStress(amount)
RPS_Lib.RelieveStress(amount)
RPS_Lib.ResetStress()          -- jg-stress-addon: real export. Others: RelieveStress(100)
RPS_Lib.SetStressLevel(amount) -- jg-stress-addon: real export. Others: computed via Gain/Relieve

--- @return boolean  jg-stress-addon only, false elsewhere
RPS_Lib.IsPlayerJobWhitelisted()

-- Server
--- @param source number
--- @return number
RPS_Lib.GetStress(source)

--- @param source number
--- @param amount number
RPS_Lib.GainStress(source, amount)
RPS_Lib.RelieveStress(source, amount)
RPS_Lib.ResetStress(source)    -- always calls RelieveStress(source, 100); no native reset export server-side

--- @param msg string
--- @param x number  @param y number  @param z number
--- @param scale number
--- @param r number  @param g number  @param b number  @param a number
RPS_Lib.Draw3DText(msg, x, y, z, scale, r, g, b, a)

--- @param msg string
--- @param coords vector3
--- @param drawDistance number|nil
RPS_Lib.Show3DTextUI(msg, coords, drawDistance)
RPS_Lib.Hide3DTextUI()

--- @param items table
--- @param title string|nil
RPS_Lib.OpenContextMenu(items, title)

--- @param title string
--- @param rows table
RPS_Lib.InputDialog(title, rows)

--- @param data table
RPS_Lib.AlertDialog(data)

--- @param npcName string
--- @param options table
RPS_Lib.OpenNpcDialogue(npcName, options)

--- @param id string
--- @param title string
--- @param tasks table
RPS_Lib.ShowChecklist(id, title, tasks)

--- @param taskIndex number
--- @param done boolean
RPS_Lib.UpdateChecklistTask(id, taskIndex, done)
RPS_Lib.HideChecklist(id)

--- @param text string
--- @param duration number|nil
RPS_Lib.ShowObjective(text, duration)
RPS_Lib.HideObjective()

--- @param entity number
--- @param cb function
RPS_Lib.UseGizmo(entity, cb)

--- @param job string
--- @return number
RPS_Lib.GetSocietyMoney(job)

--- @param job string
--- @param amount number
RPS_Lib.AddSocietyMoney(job, amount)
RPS_Lib.RemoveSocietyMoney(job, amount)

RPS_Lib.AddSocietyMoney('police', 500)
local balance = RPS_Lib.GetSocietyMoney('police')

--- @param name string
--- @return boolean
RPS.ResourceStarted(name)

RPS.Debug(...)   -- only prints if Config.Debug == true
RPS.Info(msg)    -- prints with [rps_lib] tag
RPS.Log = RPS.Info  -- alias
RPS.Warn(msg)    -- prints with WARN tag
RPS.Error(msg)   -- prints with ERROR tag

--- @param orig table
--- @return table
RPS.DeepCopy(orig)

--- @param tbl table  @param val any
--- @return boolean
RPS.TableContains(tbl, val)

--- @param target table  @param source table
--- @return table  target, mutated in place
RPS.MergeTable(target, source)

--- @param tbl table
--- @return number  works on non-sequential/mixed tables too
RPS.TableLength(tbl)

--- @param s string
--- @return string
RPS.Trim(s)

--- @param s string  @param sep string
--- @return table
RPS.Split(s, sep)

--- @param s string
--- @return string
RPS.Capitalise(s)

-- client.lua
local RPS_Lib = exports['rps_lib']:GetLibObject()

CreateThread(function()
    RPS_Lib.AddGlobalVehicle({
        options = {
            {
                label  = 'Impound Vehicle',
                icon   = 'fas fa-warehouse',
                groups = { 'police' },
                action = function(entity)
                    local plate = GetVehicleNumberPlateText(entity)
                    local netId = NetworkGetNetworkIdFromEntity(entity)
                    TriggerServerEvent('your_script:impoundVehicle', plate, netId)
                end,
            },
        },
        distance = 3.0,
    })
end)

-- server.lua
local RPS_Lib = exports['rps_lib']:GetLibObject()
local IMPOUND_FEE = 250

RegisterNetEvent('your_script:impoundVehicle', function(plate, netId)
    local source = source

    local allowed = RPS_Lib.HasPermission(source, {
        WithGroup = { police = true },
    })
    if not allowed then return end

    RPS_Lib.RemoveVehicleKey(source, plate, netId)
    RPS_Lib.AddSocietyMoney('police', IMPOUND_FEE)
    RPS_Lib.GainStress(source, 5)  -- API B, see §18 — not AddStress

    RPS_Lib.Notify(source, ('Vehicle %s impounded.'):format(plate), 'success')
    print(('^2[your_script]^7 %s impounded by %s, $%d added to police funds')
        :format(plate, source, IMPOUND_FEE))
end)