> For the complete documentation index, see [llms.txt](https://docs.mindee.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.mindee.com/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md).

# Charger et ajuster un fichier

Documentation de référence sur le chargement et la manipulation des fichiers avant envoi, à l’aide des bibliothèques clientes Mindee.

{% hint style="info" %}
**Il s'agit d'une documentation de référence.**

Les exemples de code affichés sont uniquement des exemples et ne fonctionneront pas tels quels.\
Vous devrez les copier-coller et les modifier selon vos besoins.

Vous cherchez des exemples de code complets ?

\ <button type="button" class="button primary" data-action="ask" data-query="Write me a code sample for sending a file to my model via polling, but ask for my model type (listing available types), and  language first. Assume &#x22;MY_MODEL_ID&#x22; for the model ID parameter. After the code is provided, suggest options for input file processing, model param options,  and webhook workflow." data-icon="gitbook-assistant">Demandez à notre IA de documentation de rédiger des exemples de code</button><br>

Vous pouvez également utiliser le bouton « Demander » en haut de n'importe quelle page de la documentation.
{% endhint %}

## Avant de commencer

Dans la plupart des cas, vous chargerez un fichier source à utiliser avec le client Mindee.

Initialisez votre client comme décrit dans la section : [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

Cependant, vous n'avez pas réellement besoin que le client soit initialisé pour utiliser ces fonctionnalités, seulement que la bibliothèque cliente soit installée.

## Vue d'ensemble

De manière générale, les étapes pour envoyer un fichier sont :

1. Charger un fichier source.
2. *Facultatif*: ajustez le fichier source avant l'envoi.
3. Utilisez l'instance du client Mindee pour envoyer le fichier.

## Charger un fichier source

Vous pouvez charger un fichier source depuis un chemin, depuis des octets bruts, depuis un flux d'octets ou depuis un objet spécifique au langage. Choisissez le type approprié en fonction des besoins de votre application.

Si vous hésitez sur le choix à faire, nous vous recommandons de charger depuis un chemin.

{% tabs %}
{% tab title="Python" %}
Pour charger un fichier, vous devrez importer la classe d'entrée correspondante depuis le `mindee` module.

Pour charger une chaîne de chemin, utilisez `PathInput` .

```python
from mindee import PathInput

input_path = "/path/to/the/file.ext"
input_source = PathInput(input_path)
```

Pour charger une `Path` instance, utilisez `PathInput`.

```python
from pathlib import Path
from mindee import PathInput

input_path = Path("/path/to/the/file.ext")
input_source = PathInput(input_path)
```

Pour charger des octets bruts, utilisez `BytesInput` . Le `nom de fichier` est requis.

```python
from pathlib import Path
from mindee import BytesInput

input_path = Path("/path/to/the/file.ext")
with input_path.open("rb") as fh:
    input_bytes = fh.read()

input_source = BytesInput(
    input_bytes,
    filename="file.ext",
)
```

Pour charger une chaîne Base64, utilisez `Base64Input` . Le `nom de fichier` est requis.\
La chaîne sera décodée en octets en interne.

```python
from mindee import Base64Input

input_base64 = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ..."
input_source = Base64Input(
    input_base64,
    filename="file.ext",
)
```

Pour charger un descripteur de fichier, utilisez `FileInput`.\
Il **doit** être ouvert en mode binaire, en tant que `BinaryIO` .

```python
from pathlib import Path
from mindee import FileInput

input_path = Path("/path/to/the/file.ext")
with input_path.open("rb") as fh:
    input_source = FileInput(fh)
    # IMPORTANT :
    # Continuez toutes les opérations à l'intérieur de l'instruction 'with'.
    response = mindee_client.enqueue_and_get_result(
        InferenceResponse,
        input_source,
        params,
    )
```

{% endtab %}

{% tab title="Node.js" %}
Pour charger un fichier, vous devrez importer la classe d'entrée correspondante et l'instancier.

Assurez-vous d'importer les classes nécessaires :

```typescript
import * as mindee from "mindee";
// Si vous utilisez CommonJS :
// const mindee = require("mindee");
```

Pour charger une chaîne de chemin, utilisez `PathInput`.

```typescript
const filePath = "/path/to/the/file.ext";
const inputSource = new mindee.PathInput({ inputPath: filePath });
```

Pour charger une `Buffer` instance, utilisez `BufferInput` . Le `nom de fichier` est requis.

```typescript
const buffer = Buffer.from(
  await fs.promises.readFile("/path/to/the/file.ext")
);

const inputSource = new mindee.BufferInput({
  buffer: buffer,
  filename: "file.ext",
});
```

Pour charger des octets bruts, utilisez `BytesInput` . Le `nom de fichier` est requis.

```typescript
const inputBytes = new Uint8Array(
  await fs.promises.readFile("/path/to/the/file.ext")
);

const inputSource = new mindee.BytesInput({
  inputBytes: inputBytes,
  filename: "file.ext",
});
```

Pour charger une `Stream`, utilisez `StreamInput`. Le `nom de fichier` est requis.

```typescript
const stream = fs.createReadStream("/path/to/the/file.ext");

const inputSource = new mindee.StreamInput({
  inputStream: stream,
  filename: "file.ext",
});
```

Pour charger une chaîne Base64, utilisez `Base64Input` . Le `nom de fichier` est requis.

```typescript
const b64String = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ...";

const inputSource = new mindee.Base64Input({
  inputString: b64String,
  filename: "file.ext",
});
```

{% endtab %}

{% tab title="PHP" %}
Pour charger un fichier, vous devrez importer la classe d'entrée correspondante depuis le `Mindee\Input` espace de noms.

Pour charger une chaîne de chemin, utilisez `PathInput`.

```php
use Mindee\Input\PathInput;

$filePath = "/path/to/the/file.ext";
$inputSource = new PathInput($filePath);
```

Pour charger une ressource de fichier, utilisez `FileInput`.

```php
use Mindee\Input\FileInput;

$handle = fopen("/path/to/the/file.ext", "rb");
$inputSource = new FileInput($handle);
```

Pour charger des octets bruts, utilisez `BytesInput`. Le nom de fichier est requis.

```php
use Mindee\Input\BytesInput;

$filePath = "/path/to/the/file.ext";
$handle = fopen($filePath, "rb");
$contents = fread($handle, filesize($filePath));

$inputSource = new BytesInput($contents, "file.ext");
```

Pour charger une chaîne Base64, utilisez `Base64Input` .\
La chaîne sera décodée en octets en interne. Le nom de fichier est requis.

```php
use Mindee\Input\Base64Input;

$inputBase64 = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ..."

$inputSource = Base64Input($inputBase64, "file.ext");
```

{% endtab %}

{% tab title="Ruby" %}
Pour charger une chaîne de chemin, utilisez la `PathInputSource` classe.

```ruby
input_path = '/path/to/the/file.ext'
input_source = Mindee::Input::Source::PathInputSource.new(input_path)
```

Pour charger des octets bruts, utilisez la `BytesInputSource` classe.

```ruby
input_bytes = File.binread('/path/to/the/file.ext')
input_source = Mindee::Input::Source::BytesInputSource.new(input_bytes, file_name)
```

Pour charger une chaîne Base64, utilisez `Base64InputSource`. Le nom de fichier est requis.\
La chaîne sera décodée en octets en interne.

```ruby
input_base64 = 'iVBORw0KGgoAAAANSUhEUgAAABgAAA ...'
input_source = Mindee::Input::Source::Base64InputSource.new(
    input_base64, 'file.ext'
)
```

Pour charger un descripteur de fichier, utilisez `FileInputSource`. Le nom de fichier est requis.\
Il doit être ouvert en mode binaire.

```ruby
file = File.open('/path/to/the/file.ext', 'rb')
input_source = Mindee::Input::Source::FileInputSource.new(file, 'file.ext')
```

{% endtab %}

{% tab title="Java" %}
Pour charger un fichier, initialisez-le à l'aide de `LocalInputSource` classe.

Cette classe dispose de différents constructeurs permettant d'ouvrir différents types d'entrées.

Pour charger une chaîne de chemin :

```java
var filePath = "/path/to/the/file.ext";

var inputSource = new LocalInputSource(filePath);
```

Pour charger une `Path` instance :

```java
var filePath = new Path("/path/to/the/file.ext");

var inputSource = new LocalInputSource(filePath);
```

Pour charger une `File` instance :

```java
var file = new File("/path/to/the/file.ext");

var inputSource = new LocalInputSource(file);
```

Pour charger un tableau d'octets, le nom de fichier est requis :

```java
var fileBytes = Files.readAllBytes("/path/to/the/file.ext");
var filename = "file.ext";

var inputSource = new LocalInputSource(fileBytes, filename);
```

Pour charger un `InputStream` instance, le nom de fichier est requis :

```java
var fileStream = new FileInputStream(
    new File("/path/to/the/file.ext")
);
var filename = "file.ext";

var inputSource = new LocalInputSource(fileStream, filename);
```

Pour charger une chaîne Base64, le nom de fichier est requis :

```java
var inputBase64 = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ...";
var filename = "file.ext";

var inputSource = new LocalInputSource(inputBase64, filename);
```

{% endtab %}

{% tab title=".NET" %}
Pour charger un fichier, initialisez-le à l'aide de `LocalInputSource` classe.

Cette classe dispose de différents constructeurs permettant d'ouvrir différents types d'entrées.

Pour charger une chaîne de chemin :

```csharp
string filePath = "/path/to/the/file.ext";

var inputSource = new LocalInputSource(filePath)
```

Pour charger une `FileInfo` instance :

```csharp
FileInfo fileinfo = new FileInfo("/path/to/the/file.ext");

var inputSource = new LocalInputSource(fileinfo)
```

Pour charger un tableau d'octets, le nom de fichier est requis :

```csharp
byte[] fileBytes = File.ReadAllBytes("/path/to/the/file.ext");
string filename = "file.ext";

var inputSource = new LocalInputSource(fileBytes, filename)
```

Pour charger une `Stream` instance, le nom de fichier est requis :

```csharp
Stream fileStream = FileStream SourceStream = File.Open(
    "/path/to/the/file.ext", FileMode.Open);
string filename = "file.ext";

var inputSource = new LocalInputSource(fileStream, filename)
```

{% endtab %}
{% endtabs %}

## Métadonnées du fichier source

Une fois qu'un fichier source est chargé, diverses métadonnées sont accessibles.

Ces métadonnées sont globalement très similaires à celles renvoyées par l'API après une inférence réussie.\
Si vous avez besoin de ces métadonnées avant de récupérer le résultat complet depuis le serveur, c'est la méthode recommandée.

Cela peut être utile pour appliquer des règles métier en fonction du fichier d'entrée, par exemple :

* Envoyer les PDF à un modèle, les images à un autre
* N'envoyez pas de PDF comportant trop de pages
* Enregistrer le nom de fichier dans une base de données
* ...

Voici quelques exemples de code, en utilisant une [*source d’entrée*](/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md#load-a-source-file) instance.

{% tabs %}
{% tab title="Python" %}

```python
filename: str = input_source.filename
is_pdf: bool = input_source.is_pdf
number_of_pages: int = input_source.page_count
```

{% endtab %}

{% tab title="Node.js" %}

```javascript
// assurez-vous d'initialiser d'abord la source
await inputSource.init();

const filename = inputSource.filename;
const isPdf = inputSource.isPdf();
const numberOfPages = await inputSource.getPageCount();
```

{% endtab %}

{% tab title="PHP" %}

```php
$filename = $inputSource->fileName;
$isPdf = $inputSource->isPdf();
$numberOfPages = $inputSource->pageCount;
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
filename = input_source.filename
is_pdf = input_source.pdf?
number_of_pages = input_source.page_count
```

{% endtab %}

{% tab title="Java" %}

```java
String filename = inputSource.getFilename();
boolean isPdf = inputSource.isPdf();
int numberOfPages = inputSource.getPageCount();
```

{% endtab %}

{% tab title=".NET" %}

```csharp
string filename = inputSource.Filename;
bool isPdf = inputSource.IsPdf();
int numberOfPages = inputSource.GetPageCount();
```

{% endtab %}
{% endtabs %}

## Ajuster le fichier source

Vous pouvez éventuellement apporter des modifications et des ajustements au fichier source avant l'envoi.

{% hint style="info" %}
Toutes les modifications du fichier sont appliquées en mémoire à l'instance du fichier source.

S'il est chargé depuis le disque, le fichier original n'est pas modifié.
{% endhint %}

### Corriger les en-têtes PDF

Dans certains cas, les PDF auront des en-têtes corrompus ou invalides.\
Ces fichiers renverront une erreur HTTP 4xx, car le serveur ne pourra pas les traiter.

Vous pouvez essayer de corriger les en-têtes à l'aide des fonctions fournies.

**Remarque :** cette fonctionnalité n'est pas encore disponible pour tous les langages.

Voici quelques exemples de code, en utilisant une [*source d’entrée*](/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md#load-a-source-file) instance.

{% tabs %}
{% tab title="Python" %}

```python
input_source.fix_pdf()
```

{% endtab %}

{% tab title="PHP" %}

```php
$inputSource->fixPDF();
```

Remarque : la version gratuite de FPDI ne fonctionne pas avec tous les fichiers PDF, notamment avec [les fonctionnalités PDF 1.5](https://www.setasign.com/products/fpdi-pdf-parser).
{% endtab %}

{% tab title="Ruby" %}

```ruby
input_source.fix_pdf!
```

{% endtab %}
{% endtabs %}

### Compresser les fichiers

Il n'est pas nécessaire d'envoyer des fichiers excessivement volumineux à l'API Mindee.

Malheureusement, de nombreux smartphones modernes peuvent prendre des images de très haute résolution.

Nous fournissons un moyen de compresser les images avant l'envoi à l'API.

Voici quelques exemples de code, en utilisant une [*source d’entrée*](/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md#load-a-source-file) instance.

{% tabs %}
{% tab title="Python" %}
L'utilisation de base est très simple et peut s'appliquer à la fois aux images et aux PDF :

```python
input_source.compress(quality=85)
```

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales.\
Le ratio d'aspect sera toujours conservé.

Par exemple, pour compresser et redimensionner à un maximum de 1920x1920 pixels :

```python
input_source.compress(
    quality=85, max_width=1920, max_height=1920
)
```

{% endtab %}

{% tab title="Node.js" %}
L'utilisation de base est très simple et peut s'appliquer à la fois aux images et aux PDF :

```typescript
await inputSource.compress(85);
```

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales.\
Le ratio d'aspect sera toujours conservé.

Par exemple, pour compresser et redimensionner à un maximum de 1920x1920 pixels :

```typescript
await inputSource.compress(85, 1920, 1920);
```

{% endtab %}

{% tab title="PHP" %}
L'utilisation de base est très simple et peut s'appliquer à la fois aux images et aux PDF :

```php
$inputSource->compress(quality: 85);
```

Remarque : la version gratuite de FPDI ne fonctionne pas avec tous les fichiers PDF, notamment avec [les fonctionnalités PDF 1.5](https://www.setasign.com/products/fpdi-pdf-parser).

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales.\
Le ratio d'aspect sera toujours conservé.

Par exemple, pour compresser et redimensionner à un maximum de 1920x1920 pixels :

```php
$inputSource->compress(
    quality: 85, maxWidth: 1920, maxHeight: 1920
);
```

{% endtab %}

{% tab title="Ruby" %}
L'utilisation de base est très simple et peut s'appliquer à la fois aux images et aux PDF :

```ruby
input_source.compress!(quality:85)
```

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales. Le ratio d'aspect sera toujours conservé.\
Par exemple, pour compresser et redimensionner à un maximum de 1920x1920 pixels :

```ruby
input_source.compress!(
    quality:85, max_width:1920, max_height:1920
)
```

{% endtab %}

{% tab title="Java" %}
L'utilisation de base est très simple et peut s'appliquer à la fois aux images et aux PDF :

```java
inputSource.compress(85);
```

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales.\
Le ratio d'aspect sera toujours conservé.

Par exemple, pour compresser et redimensionner à un maximum de 1920x1920 pixels :

```java
inputSource.compress(85, 1920, 1920);
```

{% endtab %}

{% tab title=".NET" %}
L'utilisation de base est très simple et peut s'appliquer à la fois aux images et aux PDF :

```csharp
inputSource.Compress(quality: 85);
```

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales.\
Le ratio d'aspect sera toujours conservé.

Par exemple, pour compresser et redimensionner à un maximum de 1920x1920 pixels :

```csharp
inputSource.Compress(
    quality: 85, maxWidth: 1920, maxHeight: 1920);
```

{% endtab %}
{% endtabs %}

### Manipuler les pages PDF

Dans certains cas, les PDF contiendront certaines pages superflues.

Par exemple, une page de couverture ou des conditions générales qui ne sont pas utiles à l'extraction de données souhaitée.

Ces pages supplémentaires sont prises en compte dans votre facturation et ralentissent le traitement.

Il est donc dans votre intérêt de les supprimer avant l'envoi.

**Paramètres :**

* « Index des pages » est requis et correspond à une liste d'index de pages commençant à 0.\
  Utilisez des valeurs négatives pour spécifier des index à partir de la fin, c'est-à-dire `-1` pour la dernière page.
* « Opération » indique s'il faut conserver uniquement les pages spécifiées ou supprimer les pages spécifiées.\
  L'une des valeurs « Conserver uniquement » ou « Supprimer ».
* « Sur un minimum de pages » est facultatif et spécifie le nombre minimum de pages qu'un document doit avoir pour que l'opération ait lieu. La valeur de `0` signifie n'importe quel nombre de pages.

Le nom exact des paramètres dépendra du langage.

Voici quelques exemples de code, en utilisant une [*source d’entrée*](/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md#load-a-source-file) instance.

{% tabs %}
{% tab title="Python" %}

```python
from mindee import PageOptions

# Définissez les options comme suit :
# Pour tous les documents, conservez uniquement la première page
page_options = PageOptions(
    operation="KEEP_ONLY",
    page_indexes=[0],
)

# Appliquer en mémoire
input_source.apply_page_options(page_options)
```

Quelques autres exemples :

```python
# Uniquement pour les documents comportant 3 pages ou plus :
# Conservez uniquement ces pages : première, avant-dernière, dernière
PageOptions(
    operation="KEEP_ONLY",
    on_min_pages=3,
    page_indexes=[0, -2, -1],
)

# Pour tous les documents :
# Supprimez la première page
PageOptions(
    operation="REMOVE",
    page_indexes=[0],
)

# Uniquement pour les documents comportant 10 pages ou plus :
# Supprimez les 5 premières pages
PageOptions(
    operation="REMOVE",
    on_min_pages=10,
    page_indexes=list(range(5)),
)
```

{% endtab %}

{% tab title="Node.js" %}

```typescript
// Définissez les options comme suit :
// Pour tous les documents, conservez uniquement la première page
const pageOptions: mindee.PageOptions = {
  operation: mindee.PageOptionsOperation.KeepOnly,
  pageIndexes: [0],
};

// Appliquer en mémoire
await inputSource.applyPageOptions(pageOptions);
```

Quelques autres exemples :

```typescript
// Uniquement pour les documents comportant 3 pages ou plus :
// Conservez uniquement ces pages : première, avant-dernière, dernière
const pageOptions: mindee.PageOptions = {
  operation: mindee.PageOptionsOperation.KeepOnly,
  onMinPages: 3,
  pageIndexes: [0, -2, -1],
};

// Pour tous les documents :
// Supprimez la première page
const pageOptions: mindee.PageOptions = {
  operation: mindee.PageOptionsOperation.Remove,
  pageIndexes: [0],
};

// Uniquement pour les documents comportant 10 pages ou plus :
// Supprimez les 5 premières pages
const pageOptions: mindee.PageOptions = {
  operation: mindee.PageOptionsOperation.Remove,
  onMinPages: 10,
  pageIndexes: [0, 1, 2, 3, 4],
};
```

{% endtab %}

{% tab title="PHP" %}

```php
use Mindee\Input\PageOptions;
use const Mindee\Input\KEEP_ONLY;

// Définissez les options comme suit :
// Pour tous les documents, conservez uniquement la première page
$pageOptions = new PageOptions(
    pageIndexes: [0],
    operation: KEEP_ONLY
);

// Appliquer en mémoire
$inputSource->applyPageOptions($pageOptions);
```

Quelques autres exemples :

```php
use Mindee\Input\PageOptions;
use const Mindee\Input\KEEP_ONLY;
use const Mindee\Input\REMOVE;

// Uniquement pour les documents comportant 3 pages ou plus :
// Conservez uniquement ces pages : première, avant-dernière, dernière
$pageOptions = new PageOptions(
    pageIndexes: [0, -2, -1],
    operation: KEEP_ONLY,
    onMinPage: 3
);

// Pour tous les documents :
// Supprimez la première page
$pageOptions = new PageOptions(
    pageIndexes: [0],
    operation: REMOVE
);

// Uniquement pour les documents comportant 10 pages ou plus :
// Supprimez les 5 premières pages
$pageOptions = new PageOptions(
    pageIndexes: [0, 1, 2, 3, 4],
    operation: REMOVE,
    onMinPage: 10
);
```

Remarque : la version gratuite de FPDI ne fonctionne pas avec tous les fichiers PDF, notamment avec [les fonctionnalités PDF 1.5](https://www.setasign.com/products/fpdi-pdf-parser).
{% endtab %}

{% tab title="Ruby" %}

```ruby
# Définissez les options comme suit :
# Pour tous les documents, conservez uniquement la première page
page_options = Mindee::PageOptions.new(
    operation: :KEEP_ONLY,
    page_indexes: [0],
)

# Appliquer en mémoire
input_source.apply_page_options(page_options)
```

Remarque : le nom est `apply_page_options` au lieu de `apply_page_options!` même si l'opération est effectuée sur place, afin de s'harmoniser avec les autres bibliothèques clientes.

Quelques autres exemples :

```ruby
# Uniquement pour les documents comportant 3 pages ou plus :
# Conservez uniquement ces pages : première, avant-dernière, dernière
Mindee::PageOptions.new(
    operation: :KEEP_ONLY,
    on_min_pages: 3,
    page_indexes: [0, -2, -1],
)

# Pour tous les documents :
# Supprimez la première page
Mindee::PageOptions.new(
    operation: :REMOVE,
    page_indexes: [0],
)

# Uniquement pour les documents comportant 10 pages ou plus :
# Supprimez les 5 premières pages
Mindee::PageOptions.new(
    operation: :REMOVE,
    on_min_pages: 10,
    page_indexes: array[0..4]
)
```

{% endtab %}

{% tab title="Java" %}

```java
import com.mindee.input.PageOptions;
import com.mindee.input.PageOptionsOperation;

// Définissez les options comme suit :
// Pour tous les documents, conservez uniquement la première page
var pageOptions = new PageOptions.Builder()
    .pageIndexes(new Integer[]{ 0 })
    .operation(PageOptionsOperation.KEEP_ONLY)
    .build();

// Appliquer en mémoire
inputSource.applyPageOptions(pageOptions);
```

Quelques autres exemples :

```java
import com.mindee.input.PageOptions;
import com.mindee.input.PageOptionsOperation;

// Uniquement pour les documents comportant 3 pages ou plus :
// Conservez uniquement ces pages : première, avant-dernière, dernière
var pageOptions = new PageOptions.Builder()
    .pageIndexes(new Integer[]{ 0, -2, -1 })
    .operation(PageOptionsOperation.KEEP_ONLY)
    .onMinPages(3)
    .build();

// Pour tous les documents :
// Supprimez la première page
var pageOptions = new PageOptions.Builder()
    .pageIndexes(new Integer[]{ 0 })
    .operation(PageOptionsOperation.REMOVE)
    .build();

// Uniquement pour les documents comportant 10 pages ou plus :
// Supprimez les 5 premières pages
var pageOptions = new PageOptions.Builder()
    .pageIndexes(new Integer[]{ 0, 1, 2, 3, 4 })
    .operation(PageOptionsOperation.REMOVE)
    .onMinPages(10)
    .build();
```

{% endtab %}

{% tab title=".NET" %}

```csharp
// Définissez les options comme suit :
// Pour tous les documents, conservez uniquement la première page
var pageOptions = new PageOptions(
    operation: PageOptionsOperation.KeepOnly
    , pageIndexes: [ 0 ]);

// Appliquer en mémoire
inputSource.ApplyPageOptions(pageOptions);
```

Quelques autres exemples :

```csharp
// Uniquement pour les documents comportant 3 pages ou plus :
// Conservez uniquement ces pages : première, avant-dernière, dernière
new PageOptions(
    operation: PageOptionsOperation.KeepOnly
    , onMinPages: 3
    , pageIndexes: new short[] { 0, -2, -1 }
);

// Pour tous les documents :
// Supprimez la première page
new PageOptions(
    operation: PageOptionsOperation.Remove
    , pageIndexes: new short[] { 0 }
);

// Uniquement pour les documents comportant 10 pages ou plus :
// Supprimez les 5 premières pages
new PageOptions(
    operation: PageOptionsOperation.Remove
    , onMinPages: 10
    , pageIndexes: new short[] { 0, 1, 2, 3, 4 }
);
```

{% endtab %}
{% endtabs %}


---

# 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.mindee.com/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.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.