Field Value Lexicon

Can be one of the following values:

Enabling this property allows the list of possible values for the field to be dynamically populated from external lookup results at runtime, in addition to any static entries.

> Note: A Lookup Specification must be defined on the parent Data Field Container (such as a Data Model, Data Section, or Data Table) for this feature to function.

When 'Include Lookup Results' is true:

• At runtime, the system queries all Lookup Specifications defined on the parent Data Field Container that target this field.
• The results of these lookups are merged with any static entries defined in the Field Value Lexicon, providing a combined list of choices.
• This process is managed by the Field Instance, which collects lookup results and merges them with static values for display and validation.
• If no static entries are defined, the list will consist solely of lookup results.

This is especially useful for fields whose valid values are maintained in an external system (such as a database or web service) and may change over time.

Example:
Enable 'Include Lookup Results' for a 'Vendor' field to present users with the current list of vendors from your ERP system, ensuring the choices are always up to date.
Make sure a Lookup Specification is configured on the parent Data Field Container to define how the lookup is performed.

For more details on how lookup results are collected and merged, see the documentation and implementation in Field Instance.

Can be one of the following values:

The 'Type' property determines the format and behavior of local entries:

• Lookup: Key-value pairs, one per line, using '=' as a delimiter.
• Vocabulary: Single values, one per line.
• Frequency: Key-count pairs, one per line, using '=' as a delimiter.

Set this property to match the intended entry format for your use case.

Overview

The 'Case Sensitive' property determines if the entries in this Embedded Lexicon will be matched using case-sensitive logic. When enabled, the exact casing of each character in the entry must match the input text for a successful match.

Usage

• Set 'Case Sensitive' to true if your data requires strict matching of uppercase and lowercase letters (for example, distinguishing between "ABC" and "abc").
• Set to false to allow case-insensitive matching, so "Invoice", "INVOICE", and "invoice" are all considered equivalent.

Practical Guidance

• For most business data (such as names, codes, or labels), case-insensitive matching (false) is recommended to improve extraction accuracy and user experience.
• Use case-sensitive matching (true) only when the distinction between uppercase and lowercase is meaningful for your use case.
• This property affects all lookups, validations, and extractions that use this Lexicon, including those performed by Data Fields, Data Tables, and custom extractors.

> Note:
> Changing this property will clear the internal cache and may affect extraction results. Review your configuration and test after making changes.

Overview

The 'Regular Expression Syntax' property determines if the entries in this Lexicon are treated as regular expressions or as plain text.

• When set to false, special characters (such as ., -, +, etc.) are automatically escaped, so entries are matched as literal text.
• When set to true, entries are passed through as-is and evaluated using .NET regular expression rules, allowing for advanced pattern matching.

Usage

• Enable this property (true) if your Lexicon contains regular expression patterns and you want to leverage pattern-based matching.
• Leave this property disabled (false) for standard word or phrase lists, where entries should be matched exactly as written.

Practical Guidance

• Use regular expressions for advanced scenarios, such as matching variable formats, optional text, or complex patterns.
• Be cautious: invalid or overly broad regular expressions can impact extraction performance or accuracy.
• When in doubt, keep this property disabled to ensure simple, literal matching.

• Enable this property to merge values from the parent field's value list with local entries and included lexicons.
• Useful for feeding the value list configured on a Data Field into an extractor such as List Match.
• To use this property, the Embedded Lexicon must exist on a Data Field or a Node which is a descendant of a Data Field.

Can be one of the following values:

Overview

The Runtime Type property displays the actual Lexicon Type used by this Embedded Lexicon at runtime. This is important when the Embedded Lexicon includes one or more external Lexicons, as their types may differ from the local Type property.

How It Works

• If one or more included lexicons are present and all share the same type, that type is used at runtime.
• If included lexicons have mixed types (e.g., some are Lookup and some are Vocabulary), the runtime type defaults to Lookup for compatibility.
• If no included lexicons are present, the value of the local Type property is used.

Usage Scenarios

• Use Runtime Type to determine how entries will be parsed and interpreted when the Embedded Lexicon is used for extraction, validation, or lookup.
• When referencing multiple external lexicons, ensure they use the same Lexicon Type for predictable behavior.
• If you need to combine lexicons of different types, be aware that the system will treat all entries as key-value pairs (Lookup) at runtime.

Example

Suppose you have:

• Local Type set to Vocabulary
• Included Lexicon A: Type = Vocabulary
• Included Lexicon B: Type = VocabularyRuntime Type will be Vocabulary.

If you add Lexicon C with Type = Lookup:

Runtime Type will be Lookup (since types are mixed).

Best Practices

• For consistent results, ensure all included lexicons use the same Lexicon Type.
• Review the Runtime Type property to verify the effective type before deploying or using the Embedded Lexicon in extraction logic.
• If you require a specific type, avoid mixing lexicons of different types.

Overview

The 'Local Entries' property allows you to define local entries for this Embedded Lexicon, one per line. The format of each entry depends on the selected 'Type' (see the 'Type' property). Local entries are merged with any included Lexicons and, if enabled, values from the parent field.

Entry Format by Lexicon Type

• Lookup:
  Each entry is a key-value pair separated by '='. Use for mapping codes to descriptions, abbreviations, or translations.

• Vocabulary:
  Each entry is a single value (word, phrase, or code), one per line. Use for simple lists of valid values, such as stopwords or allowed codes.

• Frequency:
  Each entry is a key-count pair separated by '='. Use for frequency analysis or weighted lookups.

Practical Guidance

• Place one entry per line. For Lookup and Frequency types, use '=' to separate key and value/count.
• Blank lines are ignored.
• When editing, use the code editor for syntax highlighting and validation.
• Local entries are merged with included Lexicons and parent field values (if enabled), with duplicates removed at runtime.
• Review the effective list to ensure accuracy and avoid unintended duplicates or conflicts.

Overview

The 'Lexicons' property allows you to reference one or more external Lexicons. All entries from these Lexicons are merged with local entries and, if enabled, parent field values to form the complete value list at runtime.

How It Works

• All entries from included Lexicons are merged with local entries and parent field values (if enabled).
• Duplicates are removed at runtime.
• The 'Runtime Type' property determines the effective type used for parsing and matching entries.
  • If all included Lexicons share the same type, that type is used.
  • If types are mixed, the type defaults to 'Lookup' for compatibility.

Usage Scenarios

• Share value lists across multiple fields or components by referencing a common Lexicon.
• Build composite or multi-language dictionaries by including multiple Lexicons.
• Centralize management of large or frequently updated value lists.

Practical Guidance

• Avoid circular references when including Lexicons.
• For consistent results, ensure all included Lexicons use the same Lexicon Type.
• Review the merged list to ensure there are no unintended duplicates or conflicts.
• Use the 'Included Lexicons' editor to browse and select Lexicons from the repository tree.