> For the complete documentation index, see [llms.txt](https://cristiandis.gitbook.io/ntix/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://cristiandis.gitbook.io/ntix/ntix-documentation/docs-it/api.md).

# Riferimento API

## Riferimento API di ntix-rs

`ntix-rs` è la crate Rust dietro al binario NTIX. Fornisce il parsing della configurazione, il calcolo delle differenze, l'esecuzione dei pacchetti, la gestione dello stato e il blocco dei file. La libreria core è puro dato e logica senza I/O su console; il wrapper binario (`src/main.rs`) gestisce tutta la stampa e lo spinner interattivo.

### Crate

```
ntix-rs (edizione 2024)
```

Dipendenze principali: `mlua` (Lua 5.4 incorporato), `tokio`, `clap`, `serde_json`, `regex`, `anyhow`, `async-trait`, `indicatif`, `colored`, `windows`.

### Moduli

| Modulo                      | Scopo                                                                                                                        |
| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `ntix_rs::config`           | Caricamento del file di configurazione Lua                                                                                   |
| `ntix_rs::models`           | Modelli di dati, opzioni e struct di configurazione                                                                          |
| `ntix_rs::diff`             | Calcolo delle differenze (stato desiderato vs stato corrente)                                                                |
| `ntix_rs::execution`        | Esecuzione di installazione/aggiornamento/rimozione dei pacchetti                                                            |
| `ntix_rs::state_management` | Persistenza del file di stato                                                                                                |
| `ntix_rs::package_manager`  | Operazioni per gestore (`winget_ops`, `choco_ops`, `scoop_ops`), costruzione dei comandi, parsing delle tabelle, rilevamento |
| `ntix_rs::lock`             | Blocco dell'esecuzione concorrente                                                                                           |
| `ntix_rs::paths`            | Percorsi predefiniti (`%LOCALAPPDATA%/ntix`)                                                                                 |
| `ntix_rs::process_helper`   | Controlli di amministratore / appartenenza al token                                                                          |
| `ntix_rs::hash`             | Hash del contenuto del file (tracciamento dei file di configurazione)                                                        |

### Tipi chiave

| Tipo                   | Descrizione                                                                                                   |
| ---------------------- | ------------------------------------------------------------------------------------------------------------- |
| `NTIXConfig`           | Configurazione analizzata (opzioni + elenchi di pacchetti + file di configurazione + albero di importazione)  |
| `NTIXOptions`          | Opzioni di comportamento per gestore                                                                          |
| `State`                | Pacchetti tracciati correnti, bucket scoop, file di configurazione                                            |
| `DiffResult`           | Azioni calcolate (installazione/aggiornamento/rimozione/adozione/non tracciato/file di configurazione/avvisi) |
| `InstalledPackages`    | Pacchetti trovati sul sistema (mappe per gestore)                                                             |
| `PackageManager`       | Identificatore tipizzato del gestore (`Winget`, `Chocolatey`, `Scoop`)                                        |
| `ValidationResult`     | Controllo delle capacità del gestore condiviso da diff e apply                                                |
| `ConfigFileEntry`      | Una coppia sorgente/destinazione per un file gestito                                                          |
| `CommandRunner`        | Astrazione sui comandi shell (simulabile)                                                                     |
| `ProcessCommandRunner` | Predefinito `CommandRunner` usando `cmd.exe`                                                                  |
| `parse_table`          | Analizza l'output allineato in colonne dei gestori di pacchetti                                               |
| `DiffEngine`           | `diff::diff_engine::compute_diff`                                                                             |
| `ExecutionEngine`      | `execution::execution_engine::apply_diff`                                                                     |
| `StateService`         | `state_management::state_service`                                                                             |
| `LockFile`             | `lock::lock_file::LockFile`                                                                                   |

### Avvio rapido

```rust
use ntix_rs::config::config_loader;
use ntix_rs::state_management::state_service;
use ntix_rs::diff::diff_engine;
use ntix_rs::execution::execution_engine;
use ntix_rs::package_manager::package_manager_detector;

let config = config_loader::load("config.lua".into())?;
let mut state = state_service::load_state(None).unwrap_or_default();

let progress = indicatif::ProgressBar::new_spinner();
let validation = package_manager_detector::validate_managers_async(
    &config.options, &config, None, None, None, None,
).await;

let diff = diff_engine::compute_diff(
    &config, &state,
    validation.winget_installed.then_some(true),
    validation.choco_installed.then_some(true),
    validation.scoop_installed.then_some(true),
    None, false, false, true, None, &progress,
).await?;

let state_path = state_service::get_state_path()?;
let success = execution_engine::apply_diff(
    &diff, &config.options, &mut state, &state_path, false,
    &validation, false,
    Some(&|line: &str| println!("{line}")),
    Some(&|err: &str| eprintln!("{err}")),
    None,
).await;
```