---
title: "enums"
canonical_url: "https://www.nutrient.io/api/csharp/enums/"
md_url: "https://www.nutrient.io/api/csharp/enums.md"
last_updated: "2026-10-08T08:55:57.709Z"
description: "Nutrient .NET SDK API reference for enums."
---

Types grouped under `enums` in the API reference. Import them from the `Nutrient` namespace.

```csharp

using Nutrient;

```

## Enumerations

| Enum                                                              | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ----------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`AutoTaggingEngine`](./auto-tagging-engine/)                     | Selects the engine used to build the logical structure (tags) when converting a document to a tagged, accessible PDF (PDF/UA).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [`DescriptionLevel`](./description-level/)                        | Description detail levels for Vision document description.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [`DocumentBookmarkSource`](./document-bookmark-source/)           | Specifies the source for PDF document outline (bookmarks) when converting Office documents to PDF.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [`DocumentFormat`](./document-format/)                            | Defines the format of the currently processed/used document.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [`DocumentMarkupMode`](./document-markup-mode/)                   | Specifies the modes for converting document markups, including how changes and comments are rendered.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [`DocumentType`](./document-type/)                                | The type of the document currently used.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [`ExecutionProvider`](./execution-provider/)                      | Execution provider used to run Vision ONNX model inference.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [`FormVlmEnrichmentModel`](./form-vlm-enrichment-model/)          | Which model family enriches detected form fields, and therefore which flow runs. Explicit rather than inferred from the configured provider, so a self-hosted "Custom" endpoint that happens to run a general-purpose model isn't mistaken for the dedicated form-field model.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [`HtmlLayoutType`](./html-layout-type/)                           | Specifies the desired layout type during a document conversion to HTML.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [`ImageExportFormat`](./image-export-format/)                     | Specifies the export format for images.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [`ImageExportMode`](./image-export-mode/)                         | Specifies how images are handled during document export to markup formats (Markdown, HTML).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [`ImageSettingMode`](./image-setting-mode/)                       | Specifies the mode options for image settings.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [`ImplicitConversion`](./implicit-conversion/)                    | Specifies the conversion behavior when a document format is not compatible with the editor.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [`InlineStyleReferenceMode`](./inline-style-reference-mode/)      | Reference strategy used when classifying inline text styles on OCR words.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| [`InstantJsonRenderTheme`](./instant-json-render-theme/)          | Specifies the annotation appearance theme used when importing Instant JSON.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [`JsonExportContent`](./json-export-content/)                     | Specifies which content elements to include in JSON export.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [`JsonExportFormat`](./json-export-format/)                       | Specifies formatting options for JSON export.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [`OcrActivationMode`](./ocr-activation-mode/)                     | Controls whether OCR resource loading and OCR-based word detection run inside the ICR image pipeline.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [`OcrEngine`](./ocr-engine/)                                      | Specifies which OCR engines read a page in document-processing pipelines.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| [`OpenSettingsMode`](./open-settings-mode/)                       | Defines the operational modes for opening documents.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [`PageCacheMode`](./page-cache-mode/)                             | Defines the cache mode for the page.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [`PaperNormalizationMode`](./paper-normalization-mode/)           | Controls whether the page image handed to OCR is first expressed relative to its local paper level, which lets the recognizer read tinted, faint, or unevenly lit scans.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [`PdfBorderStyle`](./pdf-border-style/)                           | Specifies the border style for annotations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [`PdfCompression`](./pdf-compression/)                            | Specifies the standard scheme to be used to compress image data in PDF documents.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [`PdfConformance`](./pdf-conformance/)                            | Specifies PDF versions and conformance levels of a PDF document. The PDF versions correspond to the PDF major releases, starting from PDF 1.0. In each PDF version the new features have been introduced. The different conformance levels reflect the quality of the archived document and depend on the input material and the documents purpose. PDF/A versions and levels are given one after another. PDF/A-1 is the first archiving standard based on PDF version 1.4. All resources must be embedded within the PDF/A document itself. PDF/A-2 is based on PDF 1.7. It allows JPEG2000 compression, transparent elements, PDF layers and more. PDF/A-3 is available since October 2012. It allows to embed any file format desired. Level a (accessible) meets all requirements for the standard. Level b (basic) guaranteed that the content of the document can be unambiguously reproduced. Level u (unicode) specifies that all text can be mapped to standard Unicode character codes. |
| [`PdfFormFieldType`](./pdf-form-field-type/)                      | Specifies the type of a PDF form field.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [`PdfLineEndingStyle`](./pdf-line-ending-style/)                  | Specifies the style of line endings for line annotations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| [`PdfPageSizes`](./pdf-page-sizes/)                               | Specifies page sizes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [`PdfRubberStampIcon`](./pdf-rubber-stamp-icon/)                  | Specifies the predefined icon for a rubber stamp annotation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [`PdfSavePreferences`](./pdf-save-preferences/)                   | Specifies preferences for saving PDF documents.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [`PdfSettingsMode`](./pdf-settings-mode/)                         | Specifies the mode options for PDF settings.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [`PdfValidationConformance`](./pdf-validation-conformance/)       | Specifies the conformance level a PDF document is validated against.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [`RenderingLayoutMode`](./rendering-layout-mode/)                 | Specifies how CAD content is laid out for rendering.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [`RestorationMode`](./restoration-mode/)                          | Controls optional restoration of the page image before vision inference.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [`SchemaCompatibility`](./schema-compatibility/)                  | Target dialect for a generated JSON Schema. Structured-output modes of the major LLM providers each accept a different subset of JSON Schema; the selected value acts as a preset filter applied on top of the individual `SchemaGenerationSettings` knobs — the effective rule is the stricter of the knob and the dialect limit, and features the dialect rejects are never emitted regardless of the knobs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [`SearchDisplay`](./search-display/)                              | How a text-search result is rendered. The matches are the same across all of these — only the presentation differs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| [`SearchMode`](./search-mode/)                                    | How aggressively a text search filters weak matches. The mode resolves to a BM-25 relevance floor: hits below it are dropped, so the caller gets a real answer or nothing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [`SignatureCertificationLevel`](./signature-certification-level/) | Specifies the certification (DocMDP) level of a signature. A certifying signature must be the first signature applied to a document and declares which subsequent changes are permitted.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [`SignatureFormat`](./signature-format/)                          | Specifies the container format of a digital signature.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [`SignatureHashAlgorithm`](./signature-hash-algorithm/)           | Specifies the hash algorithm to use when creating a digital signature.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [`SignatureKeySource`](./signature-key-source/)                   | Specifies where the signing key and certificate come from.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [`SignatureLevel`](./signature-level/)                            | Specifies the PAdES baseline level to produce when applying a digital signature.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [`TextDirection`](./text-direction/)                              | Text direction modes for reading order computation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| [`TiffCompression`](./tiff-compression/)                          | Specifies the TIFF compression when saving images in TIFF format.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [`UnitMode`](./unit-mode/)                                        | Specifies different unit modes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [`UnparseableOutputHandling`](./unparseable-output-handling/)     | How AI extraction responds when the model's output never parses against the requested schema (all retry attempts exhausted).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [`VisionEngine`](./vision-engine/)                                | Specifies which vision processing pipeline to use for content extraction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| [`VisionFeatures`](./vision-features/)                            | Vision processing features that can be enabled or disabled.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [`VisionOutputFormat`](./vision-output-format/)                   | Format of content returned by `ExtractContent` and `ExtractContentToFile`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [`VlmClassificationStrategy`](./vlm-classification-strategy/)     | Strategy for how zones are sent to the VLM for classification.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [`VlmProvider`](./vlm-provider/)                                  | Available Vision Language Model providers.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [`WordRefiningMethod`](./word-refining-method/)                   | Method used to refine handwritten word text when AI-augmented text is available.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |

---

## Related pages

- [Auto Tagging Engine](/api/csharp/enums/auto-tagging-engine.md)
- [Description Level](/api/csharp/enums/description-level.md)
- [Document Bookmark Source](/api/csharp/enums/document-bookmark-source.md)
- [Document Format](/api/csharp/enums/document-format.md)
- [Document Markup Mode](/api/csharp/enums/document-markup-mode.md)
- [Document Type](/api/csharp/enums/document-type.md)
- [Execution Provider](/api/csharp/enums/execution-provider.md)
- [Form Vlm Enrichment Model](/api/csharp/enums/form-vlm-enrichment-model.md)
- [Html Layout Type](/api/csharp/enums/html-layout-type.md)
- [Image Export Format](/api/csharp/enums/image-export-format.md)
- [Image Export Mode](/api/csharp/enums/image-export-mode.md)
- [Image Setting Mode](/api/csharp/enums/image-setting-mode.md)
- [Implicit Conversion](/api/csharp/enums/implicit-conversion.md)
- [Inline Style Reference Mode](/api/csharp/enums/inline-style-reference-mode.md)
- [Instant Json Render Theme](/api/csharp/enums/instant-json-render-theme.md)
- [Json Export Content](/api/csharp/enums/json-export-content.md)
- [Json Export Format](/api/csharp/enums/json-export-format.md)
- [Ocr Activation Mode](/api/csharp/enums/ocr-activation-mode.md)
- [Ocr Engine](/api/csharp/enums/ocr-engine.md)
- [Open Settings Mode](/api/csharp/enums/open-settings-mode.md)
- [Page Cache Mode](/api/csharp/enums/page-cache-mode.md)
- [Paper Normalization Mode](/api/csharp/enums/paper-normalization-mode.md)
- [Pdf Border Style](/api/csharp/enums/pdf-border-style.md)
- [Pdf Compression](/api/csharp/enums/pdf-compression.md)
- [Pdf Conformance](/api/csharp/enums/pdf-conformance.md)
- [Pdf Form Field Type](/api/csharp/enums/pdf-form-field-type.md)
- [Pdf Line Ending Style](/api/csharp/enums/pdf-line-ending-style.md)
- [Pdf Page Sizes](/api/csharp/enums/pdf-page-sizes.md)
- [Pdf Rubber Stamp Icon](/api/csharp/enums/pdf-rubber-stamp-icon.md)
- [Pdf Save Preferences](/api/csharp/enums/pdf-save-preferences.md)
- [Pdf Settings Mode](/api/csharp/enums/pdf-settings-mode.md)
- [Pdf Validation Conformance](/api/csharp/enums/pdf-validation-conformance.md)
- [Rendering Layout Mode](/api/csharp/enums/rendering-layout-mode.md)
- [Restoration Mode](/api/csharp/enums/restoration-mode.md)
- [Schema Compatibility](/api/csharp/enums/schema-compatibility.md)
- [Search Display](/api/csharp/enums/search-display.md)
- [Search Mode](/api/csharp/enums/search-mode.md)
- [Signature Certification Level](/api/csharp/enums/signature-certification-level.md)
- [Signature Format](/api/csharp/enums/signature-format.md)
- [Signature Hash Algorithm](/api/csharp/enums/signature-hash-algorithm.md)
- [Signature Key Source](/api/csharp/enums/signature-key-source.md)
- [Signature Level](/api/csharp/enums/signature-level.md)
- [Text Direction](/api/csharp/enums/text-direction.md)
- [Tiff Compression](/api/csharp/enums/tiff-compression.md)
- [Unit Mode](/api/csharp/enums/unit-mode.md)
- [Unparseable Output Handling](/api/csharp/enums/unparseable-output-handling.md)
- [Vision Engine](/api/csharp/enums/vision-engine.md)
- [Vision Features](/api/csharp/enums/vision-features.md)
- [Vision Output Format](/api/csharp/enums/vision-output-format.md)
- [Vlm Classification Strategy](/api/csharp/enums/vlm-classification-strategy.md)
- [Vlm Provider](/api/csharp/enums/vlm-provider.md)
- [Word Refining Method](/api/csharp/enums/word-refining-method.md)

