> For the complete documentation index, see [llms.txt](https://docs.cuxial.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.cuxial.com/scripts/es/policia-y-medico/cuxial-police/developers.md).

# Exports y eventos

API pública de Cuxial Police: exports y eventos para enviar avisos, consultar el servicio, encarcelar y más.

Envía avisos, consulta quién está de servicio, encarcela jugadores o abre la tablet desde tus propios recursos. Todo lo que no aparece aquí es interno y puede cambiar sin aviso.

Todos los exports se llaman como `exports.cuxial_police:Nombre(...)`.

## Avisos (servidor)

### SendDispatchAlert

Envía un aviso a los miembros de servicio de las facciones o trabajos elegidos.

```lua
local id = exports.cuxial_police:SendDispatchAlert(data)
```

| Campo                                       | Tipo             | Descripción                                                                          |
| ------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------ |
| `title`                                     | string           | Título del aviso. Obligatorio.                                                       |
| `message`                                   | string           | Texto del aviso.                                                                     |
| `type`                                      | string           | Tipo de aviso. También decide la facción cuando no se indica `factions` (ver abajo). |
| `severity`                                  | string           | Etiqueta libre como `'low'`, `'normal'`, `'high'`, `'critical'`.                     |
| `coords`                                    | vector3 \| table | Posición, como `vec3` o `{ x, y, z }`.                                               |
| `street`                                    | string           | Nombre de la calle.                                                                  |
| `code`                                      | string \| number | Código del aviso. Un número correlativo si se omite.                                 |
| `reporter`                                  | string           | Quién informa.                                                                       |
| `suspect`, `suspects`, `vehicle`, `weapons` | table            | Datos estructurados que muestra la tarjeta del aviso.                                |
| `images`                                    | string\[]        | URLs de imágenes.                                                                    |
| `triage`, `vitals`                          | table            | Datos médicos para avisos de EMS.                                                    |
| `metadata`                                  | table            | Datos libres.                                                                        |
| `central`                                   | boolean          | `true` añade además el aviso al tablero de Central.                                  |
| `factions`                                  | string\[]        | Destinatarios: `'police'`, `'ems'`, `'fib'`.                                         |
| `jobs`                                      | string\[]        | Nombres de trabajo. Si se indica, sustituye a `factions`.                            |

**Devuelve:** `string` con el id del aviso, o `nil` cuando los datos no son válidos.

Cuando no se indica ni `jobs` ni `factions`, la facción sale de `type`:

| `type`                                                                         | Va a                                                        |
| ------------------------------------------------------------------------------ | ----------------------------------------------------------- |
| `robbery`, `shots`, `vehicle`, `drugs`, `assault`, `chase`, `domestic`, `fire` | Policía, y la agencia federal cuando el addon está activado |
| `medical`, `crash`, `crashfire`, `cardiac`, `overdose`                         | EMS                                                         |
| Cualquier otro                                                                 | Todas las facciones                                         |

```lua
exports.cuxial_police:SendDispatchAlert({
    type = 'robbery',
    title = 'ROBO EN CURSO',
    message = 'Tienda, sospechoso armado',
    severity = 'high',
    coords = GetEntityCoords(GetPlayerPed(source)),
    central = true,
    factions = { 'police' },
})
```

### SendAlert

Forma corta del mismo aviso.

```lua
exports.cuxial_police:SendAlert(data)
```

Acepta `title`, `message`, `code`, `street`, `distance`, `coords`, `metadata`, `annotation`, `central`, `jobs`, `factions` y `type`. Sin `title` se usa uno genérico.

### AddCentralAlert

Añade una entrada al tablero de Central sin enviarla a las barras de avisos.

```lua
exports.cuxial_police:AddCentralAlert(alert)
```

| Campo      | Tipo             | Descripción                    |
| ---------- | ---------------- | ------------------------------ |
| `title`    | string           | Título.                        |
| `message`  | string           | Texto.                         |
| `code`     | string \| number | Código. Aleatorio si se omite. |
| `street`   | string           | Nombre de la calle.            |
| `coords`   | table            | Posición.                      |
| `metadata` | table            | Datos libres.                  |
| `factions` | string\[]        | Facciones que ven la entrada.  |

### ClearCentralAlerts

Vacía el tablero de Central.

```lua
exports.cuxial_police:ClearCentralAlerts()
```

## Avisos (cliente)

### SendDispatchAlert

Envía un aviso desde el jugador que informa. Acepta los mismos campos que el export de servidor, salvo `code`.

```lua
local sent = exports.cuxial_police:SendDispatchAlert(data)
```

`coords` y `street` se rellenan con la posición del jugador cuando se omiten. Cada jugador está limitado por `dispatch.sendAlertCooldown`. Cuando quien envía no es miembro de una facción, `central` y `critical` se ignoran.

**Devuelve:** `boolean`. `false` cuando `data` no es una tabla.

```lua
exports.cuxial_police:SendDispatchAlert({
    type = 'medical',
    title = 'EMERGENCIA MÉDICA',
    message = 'Persona inconsciente',
    factions = { 'ems' },
})
```

### Avisos de disparos

Cuxial Police no detecta los disparos por sí mismo. Lanza este evento de cliente desde tu recurso de armas, en el cliente del jugador que ha disparado:

```lua
TriggerEvent('cuxial:gunshot', weaponName, weaponLabel)
```

| Parámetro     | Tipo   | Descripción                                                                               |
| ------------- | ------ | ----------------------------------------------------------------------------------------- |
| `weaponName`  | string | Nombre del arma, que se comprueba contra la lista de ignoradas (`data.gunshotwhitelist`). |
| `weaponLabel` | string | Nombre que se muestra en el aviso. Opcional.                                              |

No se envía aviso cuando quien dispara está de servicio en una facción, cuando su trabajo está en `dispatch.ignoredJobs`, cuando el arma está ignorada o silenciada, ni con `dispatch.enabled = false`.

## Servicio (servidor)

| Export                                         | Devuelve      | Descripción                                                                                |
| ---------------------------------------------- | ------------- | ------------------------------------------------------------------------------------------ |
| `GetCopsOnDuty()`                              | number        | Miembros de servicio, todas las facciones juntas.                                          |
| `IsCopOnDuty(src)`                             | boolean       | Si ese jugador está de servicio en una facción.                                            |
| `GetOnDutySources()`                           | number\[]     | Ids de servidor de servicio.                                                               |
| `GetOnDutySourcesByFaction(faction)`           | number\[]     | Ids de servidor de servicio en `'police'`, `'ems'` o `'fib'`.                              |
| `GetFactionOfSource(src)`                      | string \| nil | Facción de un jugador de servicio.                                                         |
| `GetCopData()`                                 | table         | Copia de la plantilla de servicio, con el id de servidor como clave.                       |
| `SetCopReference(src, sprite, color, colorId)` | boolean       | Cambia el blip en el mapa de un miembro de servicio. Un parámetro `nil` se deja como está. |

```lua
for _, src in ipairs(exports.cuxial_police:GetOnDutySourcesByFaction('police')) do
    TriggerClientEvent('myresource:notify', src, 'Alarma del banco')
end
```

```lua
if exports.cuxial_police:GetCopsOnDuty() < 3 then
    return -- no hay unidades suficientes para este robo
end
```

## Ciudadanos (servidor)

### GetCitizenFlags

```lua
local flags = exports.cuxial_police:GetCitizenFlags(citizenid)
```

**Devuelve:** `{ wanted = boolean, dangerous = boolean }`. Los dos son `false` con un identificador vacío.

### GetAnkleByCitizen

```lua
local ankle = exports.cuxial_police:GetAnkleByCitizen(citizenid)
```

**Devuelve:** la tobillera activa de ese ciudadano, o `nil`.

## Panel de inicio (servidor)

La pestaña de inicio de la policía muestra una lista de robos recientes que alimentan tus recursos.

| Export                                   | Descripción                                                                           |
| ---------------------------------------- | ------------------------------------------------------------------------------------- |
| `AddRobbery({ name, location, status })` | Añade una entrada. `status` es `'pending'` por defecto. Se conservan las últimas 100. |
| `GetRobberies()`                         | Devuelve la lista.                                                                    |
| `ClearRobberies()`                       | Vacía la lista.                                                                       |

```lua
exports.cuxial_police:AddRobbery({ name = 'Joyería', location = 'Vinewood' })
```

## Prisión (servidor)

Estos exports actúan sobre la prisión integrada. Los meses se convierten a tiempo real con `prison.monthSeconds` y tienen como tope `limits.maxSentenceMonths`.

| Export                                   | Devuelve     | Descripción                                                                             |
| ---------------------------------------- | ------------ | --------------------------------------------------------------------------------------- |
| `Jail(src, months, reason, officerSrc)`  | boolean      | Encarcela a un jugador conectado. `reason` y `officerSrc` son opcionales.               |
| `JailOffline(citizenid, months, reason)` | boolean      | Encarcela a un ciudadano desconectado.                                                  |
| `Unjail(src)`                            | boolean      | Libera a un jugador conectado.                                                          |
| `UnjailOffline(citizenid)`               | boolean      | Libera a un ciudadano por su identificador.                                             |
| `IsJailed(src)`                          | boolean      | Si ese jugador está cumpliendo condena.                                                 |
| `GetPrisonerData(src)`                   | table \| nil | `{ jail_time, remaining_sec, months }`. `jail_time` son los meses que quedan.           |
| `GetActiveSentences()`                   | table        | Presos conectados con el id de ciudadano como clave: `{ name, months, remaining_sec }`. |

```lua
exports.cuxial_police:Jail(target, 12, 'Robo a mano armada', source)
```

## Citas médicas

### Servidor

| Export                                    | Devuelve            | Descripción                                                                           |
| ----------------------------------------- | ------------------- | ------------------------------------------------------------------------------------- |
| `CreateAppointment(data, opts)`           | fila \| nil, motivo | Reserva una cita.                                                                     |
| `GetPatientAppointments(citizenid, opts)` | table\[]            | Citas de un paciente. `opts`: `kind`, `openOnly`, `limit`.                            |
| `GetAgenda(opts)`                         | table\[]            | Citas en un intervalo. `opts`: `from`, `to` (tiempo Unix), `doctorCitizenid`, `kind`. |
| `CancelAppointment(id, reason)`           | boolean, motivo     | Cancela una cita. Se avisa al paciente cuando `lb-phone` está iniciado.               |
| `CheckInAppointment(id, citizenid)`       | boolean, motivo     | Marca la llegada del paciente.                                                        |

Campos de `data` para `CreateAppointment`:

| Campo             | Tipo   | Descripción                                                                                                                 |
| ----------------- | ------ | --------------------------------------------------------------------------------------------------------------------------- |
| `citizenid`       | string | Paciente. Obligatorio.                                                                                                      |
| `scheduledAt`     | number | Tiempo Unix de la cita. Obligatorio; tiene que ser futuro.                                                                  |
| `kind`            | string | `'consulta'` (por defecto), `'control'`, `'cura'`, `'analisis'`, `'vacuna'`, `'obstetricia'`, `'psicologia'` o `'cronico'`. |
| `durationMin`     | number | Duración en minutos, de 5 a 240.                                                                                            |
| `price`           | number | Precio. Sale de `appointments.prices` si se omite.                                                                          |
| `doctorCitizenid` | string | Médico asignado.                                                                                                            |

`opts.doctorName` es el nombre que figura como autor cuando no se indica médico.

```lua
local appointment, reason = exports.cuxial_police:CreateAppointment({
    citizenid = citizenid,
    kind = 'consulta',
    scheduledAt = os.time() + 3600,
}, { doctorName = 'Recepción' })
```

### Cliente

Para una app de teléfono o cualquier interfaz del paciente.

| Export                     | Descripción                                                            |
| -------------------------- | ---------------------------------------------------------------------- |
| `GetMyAppointments()`      | Devuelve las citas del jugador.                                        |
| `ConfirmMyAppointment(id)` | Confirma la asistencia.                                                |
| `CancelMyAppointment(id)`  | Cancela la cita.                                                       |
| `CheckInMyAppointment(id)` | Hace el check-in. El jugador tiene que estar en un punto de recepción. |

### InvalidateConditionCache

Llámalo después de escribir en la tabla `cuxial_ems_conditions` desde otro recurso, para que la comprobación de fármacos recargue a ese paciente.

```lua
exports.cuxial_police:InvalidateConditionCache(citizenid)
```

## Ajustes (servidor)

### getSetting

Devuelve el valor en vivo de una sección de ajustes.

```lua
local value = exports.cuxial_police:getSetting(id)
```

| Parámetro | Tipo   | Descripción                                                    |
| --------- | ------ | -------------------------------------------------------------- |
| `id`      | string | Id de la sección, como `'config.jobs'` o `'data.permissions'`. |

**Devuelve:** la sección como tabla plana (los vectores pasan a `{ x, y, z }`), o `nil` con un id desconocido.

```lua
local jobs = exports.cuxial_police:getSetting('config.jobs')
if jobs.policeJobs[jobName] then
    -- el trabajo pertenece a la facción de policía
end
```

## Addon federal (servidor)

Estos exports solo existen cuando el addon está activado.

| Export                                        | Devuelve     | Descripción                                                                                       |
| --------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------- |
| `FibGetCase(id)`                              | table \| nil | Un expediente.                                                                                    |
| `FibAddTimeline(id, kind, actor, text, data)` | boolean      | Añade una entrada a la cronología de un expediente. `false` si el expediente no existe.           |
| `FibGetOrgHeat(gangId)`                       | number       | Calor de una organización; `0` si no se conoce.                                                   |
| `FibCitizenFlags(citizenid)`                  | table \| nil | `{ watchlist, threat, org, warrant }`, o `nil` cuando la agencia no tiene nada del ciudadano.     |
| `FibActiveArrestWarrant(citizenid)`           | table \| nil | `{ id, number, expires_at, case_id }` de la orden de arresto activa.                              |
| `FibDevicesNear(coords, radius)`              | table\[]     | Dispositivos activos alrededor de un punto: `{ id, kind, dist }`. `radius` es `30.0` por defecto. |

```lua
local warrant = exports.cuxial_police:FibActiveArrestWarrant(citizenid)
if warrant then
    print(('Orden de arresto %s'):format(warrant.number))
end
```

## Exports de cliente

### cuxial\_mdt

Abre la tablet. Es también el manejador del item `cuxial_mdt`.

```lua
exports.cuxial_police:cuxial_mdt()
```

Los exports `prescription`, `death_certificate`, `fib_camera`, `fib_mic` y `fib_gps` son manejadores de item para el inventario y no están pensados para llamarlos a mano.

## Eventos de cliente

Eventos locales para manejar la interfaz desde otro recurso de cliente, como un menú radial.

| Evento                    | Parámetros | Qué hace                             |
| ------------------------- | ---------- | ------------------------------------ |
| `cuxial:tablet:open`      | ninguno    | Abre la tablet.                      |
| `cuxial:tablet:close`     | ninguno    | Cierra la tablet.                    |
| `cuxial:tablet:toggle`    | ninguno    | Abre o cierra la tablet.             |
| `cuxial:quickmenu:open`   | ninguno    | Abre el menú rápido.                 |
| `cuxial:quickmenu:close`  | ninguno    | Cierra el menú rápido.               |
| `cuxial:quickmenu:toggle` | ninguno    | Abre o cierra el menú rápido.        |
| `cuxial:duty:toggle`      | ninguno    | Entra o sale de servicio.            |
| `cuxial:duty:set`         | `state`    | Pone el servicio a `true` o `false`. |
| `cuxial:duty:get`         | `cb`       | Llama a `cb(onDuty)`.                |

```lua
TriggerEvent('cuxial:tablet:open')
```

Eventos que puedes escuchar:

| Evento                                  | Parámetros | Cuándo                                                       |
| --------------------------------------- | ---------- | ------------------------------------------------------------ |
| `cuxial_police:client:SetDuty`          | `state`    | Ha cambiado el estado de servicio del jugador.               |
| `cuxial_police:client:NewAlert`         | `alert`    | El jugador ha recibido un aviso.                             |
| `cuxial_police:client:JobChangeCleanup` | ninguno    | El jugador ha salido de la facción o ha cambiado de trabajo. |

```lua
RegisterNetEvent('cuxial_police:client:SetDuty', function(state)
    print(state and 'De servicio' or 'Fuera de servicio')
end)
```

## Eventos de servidor

| Evento                                  | Parámetros            | Cuándo                                                                                 |
| --------------------------------------- | --------------------- | -------------------------------------------------------------------------------------- |
| `cuxial_police:internal:JobChanged`     | `src, oldJob, newJob` | Ha cambiado el trabajo de un jugador.                                                  |
| `cuxial_police:internal:PrisonReleased` | `citizenid, cause`    | Se ha liberado a un preso de la prisión integrada. `cause` es `'served'` o `'police'`. |
| `cuxial_police:settingsApplied`         | `id`                  | Se ha aplicado una sección de ajustes. También se lanza en el cliente.                 |

```lua
AddEventHandler('cuxial_police:internal:PrisonReleased', function(citizenid, cause)
    print(('%s liberado (%s)'):format(citizenid, cause))
end)
```

## State bags

| State bag    | En      | Valor                                             |
| ------------ | ------- | ------------------------------------------------- |
| `cuffed`     | Jugador | `true` mientras el jugador está esposado.         |
| `escorted`   | Jugador | `true` mientras el jugador está siendo escoltado. |
| `escortedBy` | Jugador | Id de servidor del agente que escolta.            |

```lua
if Player(source).state.cuffed then return end
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.cuxial.com/scripts/es/policia-y-medico/cuxial-police/developers.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.