Pattern Match

The 'Value Pattern' property defines the core matching logic for the Pattern Match extractor. It uses .NET regular expression syntax to locate and extract values from document content. This pattern can be simple or highly complex, supporting named groups, merge variables, and advanced matching features.

How to Configure

• Enter a valid .NET regular expression that matches the desired value(s) in your document.
• Use named groups (?<GroupName>...) to capture sub-values and enable structured output.
• Merge variables (@VariableName) allow you to inject external values or reusable patterns.
• The pattern is applied to the preprocessed document text; all matches are returned as extraction results.

Examples

Extracting Dates (YYYY-MM-DD): (?<Year>\d{4})-(?<Month>\d{2})-(?<Day>\d{2}) Document: Invoice Date: 2023-12-31 Output: Year=2023, Month=12, Day=31

Extracting US ZIP Codes: (?<ZIP>\d{5}(?:-\d{4})?) Document: Edmond, OK 73013-1234 Output: ZIP=73013-1234

Extracting Names with Named Groups: (?<First>[A-Z][a-z]+) (?<Last>[A-Z][a-z]+) Document: John Doe Output: First=John, Last=Doe

Extracting Account Numbers with Prefix: Account\s*#\s*(?<AccountNumber>\d{8}) Document: Account # 12345678 Output: AccountNumber=12345678

Using Merge Variables: (?<Amount>@CurrencySymbol\d+.\d{2}) Where @CurrencySymbol is defined as $ or €. Document: Total: $123.45 Output: Amount=$123.45

Advanced Features

• Named Groups:
  Use named groups to capture sub-values and enable output formatting or mapping to child elements.
• Merge Variables:
  Reference external variables for reusable or dynamic pattern components.
• Fuzzy Matching:
  Enable fuzzy matching to tolerate minor OCR or typographical errors (see the 'Fuzzy Matching' property).
• Constrained Extraction:
  Restrict matching to specific regions using constrained wrap options.

Practical Tips

• Test your regular expressions using online tools or the built-in editor for Grooper.
• Use named groups for structured extraction and output formatting.
• Keep patterns as simple as possible for performance and maintainability.
• Review extraction results and diagnostic logs to refine your pattern.

For more details, see the Pattern Match wiki page and .Net Regular Expression documentation.

The 'Prefix Pattern' property allows you to specify a regular expression that must be present immediately before each match found by the Text Match extractor. This enables context-sensitive extraction, ensuring that only values preceded by a specific pattern, label, or structural element are returned.

Purpose

Use this property to restrict matches to those that occur after a particular label, whitespace, line break, or other context. This is especially useful for extracting labeled values, enforcing boundaries, or avoiding false positives in complex documents.

Configuration Guidance

• Enter a regular expression that describes the required prefix. The pattern is applied directly before each match.
• Common examples include whitespace, document labels, line or page boundaries, or exclusion of certain characters.
• Use anchors (such as ^ for start of document, \f for page break, \n for line break) to target structural positions.
• Combine multiple options using the | (OR) operator for flexibility.

Examples

Impact

• Only matches preceded by the specified pattern are included in the output.
• Improves accuracy by filtering out values that do not occur in the desired context.
• Can be used in combination with 'Suffix Pattern' for even more precise extraction.

Usage Scenarios

• Extracting values labeled with a specific phrase (e.g., Invoice No:).
• Restricting matches to the start of a page or line.
• Avoiding matches that are embedded within words or unwanted regions.

> Use diagnostics to review which prefix patterns were applied and to troubleshoot extraction boundaries.

The 'Suffix Pattern' property allows you to specify a regular expression that must be present immediately after each match found by the Text Match extractor. This enables context-sensitive extraction, ensuring that only values followed by a specific pattern, label, or structural element are returned.

Purpose

Use this property to restrict matches to those that occur before a particular label, whitespace, line break, or other context. This is especially useful for extracting values with trailing units, enforcing boundaries, or avoiding false positives in complex documents.

Configuration Guidance

• Enter a regular expression that describes the required suffix. The pattern is applied directly after each match.
• Common examples include whitespace, document labels, line or page boundaries, or exclusion of certain characters.
• Use anchors (such as $ for end of document, \f for page break, \r for line break) to target structural positions.
• Combine multiple options using the | (OR) operator for flexibility.

Examples

Impact

• Only matches followed by the specified pattern are included in the output.
• Improves accuracy by filtering out values that do not occur in the desired context.
• Can be used in combination with 'Prefix Pattern' for even more precise extraction.

Usage Scenarios

• Extracting values with trailing units or labels (e.g., acres).
• Restricting matches to the end of a page or line.
• Avoiding matches that are embedded within words or unwanted regions.

> Use diagnostics to review which suffix patterns were applied and to troubleshoot extraction boundaries.

Overview

The Environment Options class controls how merge variables are resolved and how culture information is applied during extraction. Merge variables are referenced in regular expressions using the syntax @VariableName. These variables can represent lists of values, culture-specific data, or reusable regex fragments.

Built-In Merge Variables

Several built-in merge variables are available (see Variable Providers), exposing culture-specific lists such as @DayNames, @MonthNames, and @CurrencySymbols. For example, the @DayNamesAbbreviated variable expands to a list of day abbreviations appropriate for the current culture:

• For English: Sun|Mon|Tue|Wed|Thu|Fri|Sat
• For French: dim|lun|mar|mer|jeu|ven|sam

These variables adapt automatically to the culture of the document or to a specified override.

Custom Merge Variables

You can define custom merge variables by referencing Lexicons that contain the desired values or key-value pairs. Custom variables are useful for:

• Merging in lists that are difficult to maintain directly in a regex.
• Creating libraries of reusable regex snippets shared by multiple extractors.
• Improving the readability and maintainability of complex patterns.
• Enforcing consistency across multiple extractors.

To define custom variables, use the 'Value Lists' and 'Snippet Libraries' properties to reference appropriate Lexicons. Each lexicon entry becomes a merge variable, which can be injected into your regular expressions using the @VariableName syntax.

Culture Settings

The culture used for variable expansion can be controlled via the 'Culture Override' and 'Culture Scope' properties. By default, variables are generated using the culture of the input document, but you can force a specific culture or restrict processing to certain languages using these options.

This is especially useful when extracting data from mixed-language documents, or when you need to standardize extraction behavior across different locales.

Usage Guidance

• Use built-in variables for common culture-specific lists.
• Reference Lexicons to define custom lists or regex snippets as merge variables.
• Adjust culture settings to match your extraction requirements, especially for multilingual or internationalized content.
• For more details on configuring merge variables and culture options, see the documentation for Lexicons, Variable Providers, and the relevant properties of this class.

The 'Case Sensitive' property controls whether the regular expression pattern, prefix, and suffix matching performed by the Text Match extractor will distinguish between uppercase and lowercase letters.

Purpose

Enable this property when the capitalization of text is meaningful for your extraction scenario, such as distinguishing between proper names, acronyms, or case-specific labels.

Configuration Guidance

• Set to true to require exact case matches (e.g., "Invoice" ≠ "invoice").
• Set to false to allow matches regardless of case (e.g., "Invoice", "INVOICE", and "invoice" are all equivalent).
• Use case-sensitive matching for scenarios where capitalization conveys meaning, such as extracting section headings, entity names, or codes that are case-dependent.
• For most business data, case-insensitive matching (false) is recommended to maximize extraction accuracy.

Impact

• When enabled, only text that matches the exact case of the pattern will be extracted.
• When disabled, matches will be found regardless of case, increasing the number of potential hits.

Examples

> Use diagnostics to verify which matches were found and to troubleshoot case-related extraction issues.

The Text Preprocessor enables advanced manipulation of control characters in a document's text, allowing regular expressions to match or ignore structural elements such as line breaks, paragraph boundaries, page breaks, tabs, and spaces.

Overview

Text preprocessing is performed immediately before extraction, transforming the document's text to improve the accuracy and flexibility of pattern matching. This is especially useful when data values span multiple lines, are separated by large whitespace gaps, or are affected by inconsistent formatting.

Key Features

• Paragraph Marking:
  Detects paragraph boundaries and converts line breaks within paragraphs to spaces, while preserving paragraph-ending breaks. This allows extractors to match values that span multiple lines within a paragraph, without matching across paragraph boundaries. See Paragraph Marker.

• Tab Marking:
  Replaces large horizontal whitespace gaps with TAB characters, making it possible to distinguish between normal spaces and significant gaps in regular expressions. See Horizontal Tab Marker.

• Vertical Tab Marking:
  Converts certain line breaks to vertical tab characters based on vertical spacing, enabling recognition of vertical structure in tabular or multi-column layouts. See Vertical Tab Marker.

• Control Character Ignoring:
  Removes or replaces selected control characters (such as spaces, newlines, form feeds, and carriage returns) according to the 'Ignore Control Characters' setting. This can simplify extraction in documents with inconsistent or excessive whitespace.

Usage Guidance

• Configure the desired preprocessing options by enabling or disabling paragraph, tab, and vertical tab marking, and by selecting which control characters to ignore.
• Preprocessing is typically used in conjunction with regular expression-based extractors, but can benefit any extraction scenario where document structure affects pattern matching.
• For best results, adjust preprocessing settings to match the structure and formatting of your source documents.

Example Scenarios

• Extracting values that span multiple lines within a paragraph:
  Enable paragraph marking to convert internal line breaks to spaces, allowing regular expressions to match values split across lines.

• Distinguishing between normal spaces and large gaps:
  Enable tab marking to insert TAB characters at significant horizontal gaps, so extractors can target fields separated by large whitespace.

• Cleaning up unwanted whitespace or control characters:
  Use the 'Ignore Control Characters' option to remove or replace problematic characters that interfere with extraction.

For more details, see the documentation for Paragraph Marker, Horizontal Tab Marker, and Vertical Tab Marker.

Examples

1. Sample Document

Consider the following sample document.

┌─────────────────────────────────────────────────────────────┐
│                        SAMPLE FORM                          │
├─────────────────────────────────────────────────────────────┤
│ Name:           John Doe                   ID: 12345        │
│ Date of Birth:  01/01/1980                 Status: Active   │
├─────────────────────────────────────────────────────────────┤
│ This is the first paragraph. It explains the purpose of     │
│ the form and the meaning of each field.                     │
│                                                             │
│ Please complete all fields and verify all personal          │
│ information before submitting. Thank you!                   │ 
└─────────────────────────────────────────────────────────────┘

2. Default Control Characters

With no preprocessing options enabled, the document data will look like this. Whitespace gaps, no matter how large, are represented by a single space character. A \r\n pair marks each location where the original document wrapped to the next line.

SAMPLE FORM\r\n
Name: John Doe ID: 12345\r\n
Date of Birth: 01/01/1980 Status: Active\r\n
This is the first paragraph. It explains the purpose of\r\n
the form and the meaning of each field.\r\n
Please complete all fields and verify all personal\r\n
information before submitting. Thank you!\r\n

3. Preprocessed Version

Preprocessing the document with paragraph marking and tab marking will place a tab character '\t' at each large whitespace gap, and replace newline pairs '\r\n' occuring inside a paragraph with a space.

SAMPLE FORM\r\n
Name: John Doe\tID: 12345\r\n
Date of Birth: 01/01/1980\tStatus: Active\r\n
This is the first paragraph. the form and the meaning of each field.\r\n
Please complete all fields and verify all personal information before submitting. Thank you!\r\n

Can be one of the following types:

Unlike a normal regular expression, which finds values exactly matching the pattern, a fuzzy regular expression (FRX) finds values which match the pattern to a specific degree of similarity, and automatically repairs the output value whenever possible.

When using FRX mode, there are a few limitations on regular expression syntax and some performance implications which need to be considered. These are outlined below.

Regular Expression Syntax

Fuzzy regular expressions support most of the syntax and features of standard regular expressions, with a handful of exceptions noted below. The following regular expression features are NOT supported in FuzzyRegEx mode:

• Quantifiers : + and *. Also, the 'few times as possible' construct (i.e. \w*?) is not supported.
• Character Escapes : \a \b \e \nnn \cX \cx \unnnn.
• Character Classes : \p{name} abd \P{name}
• Grouping Constructs : Only basic named and unnamed group constructs are supported
• Other: Anchors other than ^ and $, Backreference Constructs, and Alternation Constructs are unsupported.

FRX also supports an option which is unavailable in normal regular expressions. (?r) will turn on required mode, and (?-r) will turn it off. At the start of an FRX, required mode always defaults to off. Once turned on, required mode will stay on until it is turned off. This mechanism can be used, for example, to require the start of a new line. The syntax to accomplish this would be be (?r)\n(?-r).

Performance Considerations

The processing time for an FRX is considerably longer than a normal regular expression, particularly for complex regular expressions. The execution time is proportional to the perplexity of the regular expression - which measures the number of possible permutations in the pattern. For example:

• A{1,2}B{1,2} has a perplexity of 2 * 2 = 4 (i.e. it could match AB, AAB, ABB, or AABB).
• A{1,2}B{1,2}C{1,2} has a perplexity of 2 * 2 * 2 = 8.
• A{1,5}B{1,5}C{1,5} has a perplexity of 5 * 5 * 5 = 125.
• [0-9]{4} (miles|kilometers) has a perplexity of 1 * 2 = 2.
• [0-9]{1,5} (miles|kilometers) has a perplexity of 5 * 2 = 10.

There is a point at which perplexity gets so high that fuzzy matching is computationally impractical. As such, FRX is not suitable for every extraction task, and should be used with caution.

Can be one of the following types:

The Constrained Wrap Options class enables extraction of values that span line breaks inside a defined region, such as a table cell or boxed area. This is useful for scenarios where data (like numbers, dates, or labels) may be split across lines due to formatting or limited space.

For example, enabling this option allows a pattern like \d+ acres to match "340 acres" in the following document, even though the value wraps across two lines:

Table headers also frequently wrap text inside a box, as shown below:

How It Works

When enabled, this option combines the text content from a region (such as a table cell) into a single string, replacing line breaks with spaces. Extraction patterns are then applied to this combined text, allowing matches that span multiple lines.

You can further constrain which regions are considered by specifying minimum and maximum values for width, height, character count, and line count using the properties below.

Usage Guidance

• Use Constrained Wrap Options when extracting data from documents where values may be split across lines within a bounded area.
• Adjust the 'Width Range', 'Height Range', 'Character Count', and 'Line Count' properties to target only regions of interest and avoid false positives.
• This option is especially useful for extracting data from table headers, boxed fields, or any layout where text wrapping is common.

The 'Minimum Group Hits' property controls the validation requirements for group lookups within the extraction process. When extracting values using named groups and group-specific options, this property determines how many groups must successfully pass their lookup or validation criteria for the overall result to be included.

How It Works

• If set to 0, any failed group lookup will cause the result to be excluded.
• If set to a positive integer (e.g., 2), at least that many group lookups must succeed for the result to be valid.
• This is useful when some groups are optional or when partial matches are acceptable in your extraction scenario.

Usage Scenarios

• Strict Validation:
  Set to the total number of groups to require all lookups to succeed.
• Partial Acceptance:
  Set to a lower value to allow results where only some groups are validated (e.g., at least 2 out of 3).

Practical Tips

• Use this property to balance strictness and flexibility in multi-group extraction scenarios.
• Review extraction results to determine the optimal threshold for your data quality and business requirements.

For more information, see the documentation for Group Options and Pattern Match.

The 'Chunk Size' property enables chunked processing for large documents, allowing the Text Match extractor to break the document into smaller segments and process each chunk separately.

Purpose

Use this property to optimize extraction performance and memory usage when working with documents containing many pages (hundreds or thousands).

Configuration Guidance

• Enter the number of pages per chunk (e.g., 1000).
• If set to a value greater than zero, the extractor will process the document in chunks of the specified size.
• If left at 0, chunked processing is disabled and the entire document is processed as a single unit.
• Choose a chunk size that balances performance and resource usage for your environment.

Impact

• Reduces memory consumption and improves responsiveness for very large documents.
• Extraction results from each chunk are combined into the final result set.
• May affect the ability to match patterns that span chunk boundaries; adjust chunk size as needed.

Usage Scenarios

• Processing scanned books, contracts, or reports with thousands of pages.
• Avoiding out-of-memory errors or slow extraction times on large documents.
• Tuning chunk size to match available system resources and desired throughput.

> Use diagnostics to review chunk boundaries, extraction times, and the number of results produced per chunk.

The 'Lookup Options' property enables post-extraction validation and normalization of values found by the regular expression pattern. It uses a Value Lookup configuration to enforce allowed values, discard unwanted values, correct spelling or OCR errors, and map values to standardized forms or abbreviations.

How to Configure

• Vocabulary:
  Specify a list of allowed values. Only values present in the vocabulary are accepted unless 'Allow Miss' is enabled.
• Exclusions:
  Specify a list of disallowed values. Any value in this list is always discarded, even if present in the vocabulary.
• Fuzzy Lookup:
  Enable fuzzy matching to automatically correct minor spelling or OCR errors. Values not found in the vocabulary are checked for close matches.
• Translation:
  Map values to replacements using key-value pairs in the vocabulary. Useful for abbreviation mapping or normalization.
• Additional Options:
  Control case normalization, punctuation cleaning, and whether to allow values not found in the vocabulary.

Usage Scenarios

• Strict Validation:
  Enforce that only values from a controlled list (such as codes, states, or product names) are accepted.
• Spell Correction:
  Automatically correct common OCR or typographical errors using fuzzy matching.
• Abbreviation Mapping:
  Map full names to abbreviations or vice versa using the 'Translate' option and key-value pairs in the vocabulary.
• Exclusion Filtering:
  Discard unwanted values (such as "N/A", "Unknown", or blacklisted terms) using the exclusions list.

Practical Tips

• Review and maintain vocabularies and exclusions for accuracy and completeness.
• Enable fuzzy matching for noisy or variable data, but monitor performance and accuracy.
• Use translation rules to standardize output for downstream processing or reporting.
• Combine LookupOptions with group-specific options for granular control over multi-field extraction.

For more information, see the documentation for Value Lookup, Group Options, and Pattern Match.

The 'Group Options' property allows you to define specialized validation, normalization, and translation settings for each named group captured by the 'Value Pattern'. This enables fine-grained control over how individual groups are processed, supporting scenarios where different data elements require distinct vocabularies, exclusions, or confidence thresholds.

How to Configure

• Each entry in 'Group Options' corresponds to a named group in your regular expression (e.g., (?<State>...)).
• For each group, you can specify allowed values (vocabulary), exclusions, fuzzy matching similarity, and translation rules.
• Use the editor to add, remove, or modify group-specific options as needed for your extraction scenario.

Usage Scenarios

• State Validation:
  For a pattern like State of (?<State>[A-Z]+), configure the 'State' group to only accept valid state names.
• Multi-Field Extraction:
  When extracting multiple fields (e.g., City, State, ZIP), assign different vocabularies or exclusions to each group.
• Fuzzy Correction:
  Enable fuzzy matching for groups prone to OCR errors, such as names or codes.

Practical Tips

• Use descriptive group names to clarify the purpose of each configuration.
• Regularly review group-specific vocabularies and exclusions to ensure accuracy.
• Adjust confidence thresholds based on the quality and variability of data in each group.

For more information, see the documentation for Group Options, Value Lookup, and Pattern Match.

The 'Output Format' property enables you to transform and normalize the extracted value using a template that references named groups from the regular expression pattern. This allows you to control the presentation, structure, and data type of the output, making it suitable for downstream processing, reporting, or export.

How to Configure

• Use literal characters and group placeholders in the format string. Group placeholders take the form {GroupName}.
• You can expand placeholders to include typecasting and .NET format specifiers: {GroupName:TypeCast:FormatSpecifier}.
• The format string is applied to each match, producing a normalized output value.

Examples

Reformatting Names:

• Regular Expression: (?<First>[A-Z]+) (?<Last>[A-Z]+)
• Output Format: {Last}, {First}
• Document: John Doe
• Result: Doe, John

Formatting Dates:

• Regular Expression: (?<Y>\d{4})(?<M>\d{2})(?<D>\d{2})
• Output Format: {M}/{D}/{Y}
• Document: 20170222
• Result: 02/22/2017

Typecasting and Numeric Formatting:

• Regular Expression: (?<A>[A-Z]{2})(?<B>\d{6})
• Output Format: {A}-{B:Integer:00000000}
• Document: YM592034
• Result: YM-00592034

Currency Formatting:

• Regular Expression: (?<Amount>\d+.\d{2})
• Output Format: ${Amount:Decimal:C2}
• Document: 1234.56
• Result: $1,234.56

Advanced Features

• TypeCast:
  Specify the desired data type for a group value: DateTime, Decimal, Double, Integer, or String. If conversion fails, the result is excluded.
• FormatSpecifier:
  Use any valid .NET format specifier for the chosen type. This allows for custom date, time, and numeric formatting.
• Group Placeholders:
  Reference any named group from the regular expression for flexible output construction.

Practical Tips

• Use output formatting to standardize extracted values for export, reporting, or integration.
• Test format strings with sample data to ensure correct results and type conversions.
• Combine output formatting with group options and lookups for robust normalization.

Microsoft Documentation Links

For complete documentation on .NET format specifiers, see:

• Standard DateTime Formats
• Custom DateTime Formats
• Standard Numeric Formats
• Custom Numeric Formats

For more details, see the Pattern Match wiki page.

A combination of the following flags:

The FormatOptions enumeration provides advanced control over the formatting and alignment of extracted values when using an Output Format in Grooper. These options affect how literal characters and group placeholders in the format string are processed, aligned, and mapped to the document's OCR data.

How It Works

• Options can be combined to achieve precise output formatting and alignment.
• Use these settings to ensure that the output value matches the document's layout, restricts extraction zones, or aligns literal characters for improved accuracy.

Practical Guidance

• Choose 'Restrict' to limit extraction to the bounds of the formatted output value, useful for table cells or tightly-bounded regions.
• Choose 'Align' to ensure literal characters in the output format (such as punctuation or spaces) are mapped to their actual positions in the OCR text, improving extraction fidelity.
• Use 'None' for standard output formatting without additional alignment or zone restriction.

The Result Filter allows you to configure a set of criteria that each Data Instance must meet to be included in the final result set. Results that do not match the specified conditions are excluded, enabling precise control over which values are retained for downstream processing or export.

Configuration and Usage

• Configure filter properties to target results by page, confidence, length, character composition, geometric region, font size, alignment, and more.
• Multiple filter criteria can be combined; a result must satisfy all enabled filters to be included.
• Use the 'Allowed Pages' property to restrict results to specific pages.
• Set 'Minimum Confidence' to exclude low-confidence results.
• Use 'Length Range' and 'Character Classes' to filter by value length and character makeup.
• The 'Exclusions' property allows you to specify a Value Extractor whose results will be used to exclude overlapping matches.
• Geometric filters (such as 'Region', 'Width Range', 'Height Range', and 'Font Size Range') allow you to target results by their position and size on the page.
• Emphasis filters (such as 'Character Casing', 'Case Similarity', 'Minimum Font Scale', and 'Require Underline') help isolate results with specific visual or typographic emphasis.

Typical Scenarios

• Restricting to a Region:
  Only include results that fall within a specific area of the page, such as a header or footer.
• Filtering by Confidence:
  Exclude results below a certain confidence threshold to improve data quality.
• Targeting Emphasized Text:
  Isolate headings, titles, or other elements with distinctive font size, casing, or underlining.
• Excluding Unwanted Results:
  Use the 'Exclusions' property to remove results that overlap with known false positives or irrelevant content.

Related Types

• Data Instance: The objects being filtered.
• Value Extractor: Used for exclusion filtering.
• Character Class Filter, Logical Rectangle, Logical Range, Horizontal Alignment Settings: Used for specific filter criteria.

For more information, see the documentation for Data Instance, Value Extractor, and Result Filter properties.

The Result Set Options class provides a flexible set of controls for shaping the output of data extraction and classification activities in Grooper. It allows you to define how individual results are adjusted, how the overall result set is filtered or ordered, and how output values are normalized for downstream use.

Overview

Use this class to:

• Normalize extracted values (e.g., unify variations, apply case or word transformations).
• Adjust or override confidence scores for results.
• Remove unwanted content from output values.
• Sort, filter, or deduplicate the result set.
• Enforce minimum/maximum hit counts or truncate the number of results.

These options are commonly configured on Data Fields, Data Types, or other extraction elements to ensure that the output meets business requirements and is ready for validation, export, or further processing.

Key Scenarios

• Value Normalization:
  Use 'Value Override', 'Case Normalization', or 'Word Normalization' to standardize output values, making them consistent for classification or export. For example, you can map multiple document title variations to a single normalized feature, or apply stemming to treat inflected word forms as equivalent.

• Confidence Adjustment:
  The 'Confidence Override' and 'Confidence Multiplier' properties allow you to boost or reduce the confidence of results, influencing their precedence in classification or extraction. You can also factor in character-level OCR confidence for more granular control.

• Result Set Shaping:
  Use 'Hit Count Range' to require a specific number of results, 'Distinct' to remove duplicates, 'Sort Order' to control result ordering, and 'Truncate At' to limit the number of returned results.

• Content Removal:
  The 'Subtractor' property lets you specify a Value Extractor to remove unwanted content (such as extraneous text or formatting) from each output value.

Processing Flow

When applied, the options in this class are processed in a defined sequence:

1. Individual Value Adjustments:
   Each result is normalized, cleaned, or transformed according to the configured options.
2. Result Set Operations:
   The set of results is filtered, sorted, deduplicated, or truncated as specified.
3. Type Enforcement:
   If a specific value type is required, results are converted and validated accordingly.

This ensures that the final output is both clean and conforms to the requirements of downstream consumers.

Usage Guidance

• Configure only the options relevant to your scenario; defaults are designed to minimize unnecessary processing.
• For best results, test your configuration with representative data to ensure that normalization, filtering, and confidence adjustments behave as expected.
• For more details on individual options, see the documentation for each property.