Template:TypeName: Difference between revisions

From Grooper Wiki
← Older edit
No edit summary
No edit summary
 
(24 intermediate revisions by the same user not shown)
Line 1: Line 1:
{{#switch: {{{1}}}
{{#switch: {{{1}}}
| Grooper Object = Grooper.GrooperObject
| Embedded Object = Grooper.EmbeddedObject
| Connected Object = Grooper.ConnectedObject
| Object Clipboard Data = Grooper.ObjectClipboardData
| Capture Device = Grooper.Capture.CaptureDevice
| Checkout Info = Grooper.CheckoutInfo
| ColorTracScanner = Grooper.Capture.ColorTrac.ColorTracScanner
| User Connections = Grooper.UserLicense
| Import Device = Grooper.Capture.ImportDevice
| Premium Features = Grooper.PremiumFeatures
| ISIS Device = Grooper.Capture.IsisDevice
| MultiCommand(Of Object Type) = Grooper.MultiCommand`1
| TWAIN Device = Grooper.Capture.TwainDevice
| Typed Command = Grooper.TypedCommand
| Import Provider = Grooper.Core.ImportProvider
| TypedCommand(Of Object Type) = Grooper.TypedCommand`1
| Cmis Import Base= Grooper.CMIS.CmisImportBase
| Image Compression = Grooper.ImageCompression
| Import Descendants = Grooper.CMIS.ImportDescendants
| JPEG = Grooper.JpegCompression
| Import Query Results = Grooper.CMIS.ImportQueryResults
| Legacy Transym License = Grooper.TransymLicense
| File Import = Grooper.Core.FileImport
| Connection License = Grooper.ConnectionLicense
| File System Import = Grooper.Core.FileSystemImport
| Designer Connections = Grooper.DesignerLicense
| FTP Import = Grooper.Messaging.FtpImport
| Classification Volume = Grooper.DocumentClassification
| SFTP Import = Grooper.Messaging.SftpImport
| Extraction Volume = Grooper.FieldExtraction
| HTTP Import = Grooper.Messaging.HttpImport
| File Volume = Grooper.FileVolume
| Mail Import = Grooper.Messaging.MailImport
| Page Volume = Grooper.PageVolume
| OPEX Import = Grooper.Core.OxiImport
| Volume License = Grooper.VolumeLicense
| Search Import = Grooper.GPT.SearchImport
| Worker Connections = Grooper.WorkerLicense
| Test Batch = Grooper.Core.TestBatchImport
| Product License = Grooper.ProductLicense
| Node = Grooper.GrooperNode
| Database Upgrader = Grooper.DatabaseUpgrader
| AI Assistant = Grooper.GPT.AIAssistant
| File Reference = Grooper.FileReference
| Batch Object = Grooper.Core.BatchObject
| URL File Reference = Grooper.URLFileReference
| Batch Folder = Grooper.Core.BatchFolder
| UNC File Reference = Grooper.UNCFileReference
| Batch = Grooper.Core.Batch
| Resource File Reference = Grooper.ResourceFileReference
| Batch Page = Grooper.Core.BatchPage
| Type Permissions = Grooper.TypePermissions
| Batch Process = Grooper.Core.BatchProcess
| Remote Repository = Grooper.RemoteRepository
| Batch Process Step = Grooper.Core.BatchProcessStep
| Permission Set = Grooper.PermissionSet
| CMIS Connection = Grooper.CMIS.CmisConnection
| Index Table = Grooper.IndexTable
| CMIS Repository = Grooper.CMIS.CmisRepository
| IndexTable(Of Node Type) = Grooper.IndexTable`1
| Content Type = Grooper.Core.ContentType
| Repository Stats = Grooper.RepositoryStats
| Content Category = Grooper.Core.ContentCategory
| Node Description Editor = Grooper.NodeDescriptionEditor
| Content Model = Grooper.Core.ContentModel
| Repository Option = Grooper.RepositoryOption
| Document Type = Grooper.Core.DocumentType
| Node Information = Grooper.NodeInformation
| Form Type = Grooper.Core.FormType
| Clipboard Data = Grooper.ClipboardData
| Page Type = Grooper.Core.PageType
| Properties Clipboard Data = Grooper.PropertiesClipboardData
| Control Sheet = Grooper.Capture.ControlSheet
| Connected Object = Grooper.ConnectedObject
| Data Connection = Grooper.Core.DataConnection
| Span = Grooper.Span
| Data Element = Grooper.Core.DataElement
| ObjectCommand(Of Object Type) = Grooper.ObjectCommand`1
| Data Field = Grooper.Core.DataField
| Archive Info = Grooper.ArchiveInfo
| Data Column = Grooper.Core.DataColumn
| Node = Grooper.GrooperNode
| Data Field Container = Grooper.Core.DataFieldContainer
| Project = Grooper.Project
| Data Element Container = Grooper.Core.DataElementContainer
| Root = Grooper.GrooperRoot
| Data Model = Grooper.Core.DataModel
| Projects Folder = Grooper.ProjectsFolder
| Data Section = Grooper.Core.DataSection
| Resource File = Grooper.ResourceFile
| Data Table = Grooper.Core.DataTable
| Folder Browse Editor = Grooper.FolderBrowseEditor
| Data Rule = Grooper.Core.DataRule
| Reference List Editor = Grooper.MultiNodeReferenceEditor
| Extractor Node = Grooper.Core.ExtractorNode
| MultiNodeReferenceEditor(Of Node Type) = Grooper.MultiNodeReferenceEditor`1
| Data Type = Grooper.Extract.DataType
| All Nodes Reference Editor = Grooper.AllNodesReferenceEditor
| Field Class = Grooper.Extract.FieldClass
| Node Reference Editor = Grooper.NodeReferenceEditor
| Value Reader = Grooper.Extract.ValueReader
| NodeReferenceEditor(Of Object Type) = Grooper.NodeReferenceEditor`1
| File Store = Grooper.FileStore
| Check List Editor = Grooper.CheckListEditor
| Folder = Grooper.Folder
| PgCheckListEditor(Of Instance Type, Element Type) = Grooper.PgCheckListEditor`2
| Batches Folder = Grooper.Core.BatchesFolder
| Open File Editor = Grooper.PgOpenFilePathEditor
| Local Resources Folder = Grooper.Core.LocalResourcesFolder
| File Directory Editor = Grooper.PgFolderPathEditor
| Machines = Grooper.MachinesFolder
| Choice Property Editor = Grooper.PgListEditor
| Machines Folder = Grooper.MachinesFolder
| PgListEditor(Of Instance Type, Property Type) = Grooper.PgListEditor`2
| Projects Folder = Grooper.ProjectsFolder
| Object Collection Editor = Grooper.ObjectCollectionEditor
| IP Element = Grooper.IP.IpElement
| Text Property Editor = Grooper.TextPropertyEditor
| IP Element Container = Grooper.IP.IpElementContainer
| Object Properties Editor = Grooper.PgPropGridEditor
| IP Group = Grooper.IP.IpGroup
| Property Editor = Grooper.PropertyEditor
| IP Profile = Grooper.IP.IpProfile
| Reference Editor Base = Grooper.ReferenceEditorBase
| IP Step = Grooper.IP.IpStep
| Blank Zero Converter = Grooper.BlankZeroConverter
| Lexicon = Grooper.Core.Lexicon
| Type Selector = Grooper.ObjectTypeConverter
| Machine = Grooper.Machine
| ObjectTypeConverter(Of Object Type, Property Type) = Grooper.ObjectTypeConverter`2
| Object Library = Grooper.ObjectLibrary
| Check List Converter = Grooper.CheckListConverter
| OCR Profile = Grooper.OCR.OcrProfile
| CheckListConverter(Of Owner Type, Element Type) = Grooper.CheckListConverter`2
| Project = Grooper.Project
| Expandable Converter = Grooper.ExpandableConverter
| Resource File = Grooper.ResourceFile
| Expandable Info Converter = Grooper.ExpandableInfoConverter
| Root = Grooper.GrooperRoot
| Pg Dictionary Converter = Grooper.PgDictionaryConverter
| Scanner Profile = Grooper.Capture.ScannerProfile
| Pg Flags Converter = Grooper.PgFlagsConverter
| Separation Profile = Grooper.Capture.SeparationProfile
| Choice Converter = Grooper.ChoiceConverter
| Training Page = Grooper.Core.TrainingPage
| PgListConverter(Of Object Type, Property Type) = Grooper.PgListConverter`2
| Batch = Grooper.Core.Batch
| Read Only Converter = Grooper.ReadOnlyConverter
| Work Queue = Grooper.Core.WorkQueue
| Session Stats = Grooper.SessionStats
| Processing Queue = Grooper.Core.ThreadPool
| Code Property Editor = Grooper.PgCodeEditor
| Review Queue = Grooper.Core.ReviewQueue
| PgCodeEditor(Of Object Type) = Grooper.PgCodeEditor`1
| Database Row = Grooper.DatabaseRow
| Code Expression Editor = Grooper.CodeExpressionEditor
| Service Instance = Grooper.ServiceInstance
| CodeExpressionEditor(Of Object Type) = Grooper.CodeExpressionEditor`1
| Service = Grooper.ServiceInstance
| On Off Converter = Grooper.OnOffConverter
| Activity Processing = Grooper.Services.ActivityProcessing
| Verbose On Off Converter = Grooper.VerboseOnOffConverter
| API Services = Grooper.Services.ApiServices
| Override Converter = Grooper.OverrideConverter
| Import Watcher = Grooper.Services.ImportWatcher
| Click to Edit Converter = Grooper.PgClickToEditConverter
| Indexing Service = Grooper.GPT.IndexingService
| Pg Text Lines Converter = Grooper.PgTextLinesConverter
| System Maintenance Service = Grooper.Services.SystemMaintenanceService
| Pg Format Converter = Grooper.PgFormatConverter
| Timer Service = Grooper.Services.TimerService
| Pg Type Display Name Converter = Grooper.PgTypeDisplayNameConverter
| Web Service = Grooper.Services.WebService
| Command = Grooper.ObjectCommand
| Grooper Licensing = Grooper.Services.LicenseService
| Grooper Object = Grooper.GrooperObject
| Embedded Object = Grooper.EmbeddedObject
| Degrees Converter = Grooper.PgDegreesConverter
| #default = Default result
| Square Angle Converter = Grooper.SquareAngleConverter
}}
| Percent Converter = Grooper.PgPercentConverter
| Collection Converter = Grooper.PgCollectionConverter
| Pg Ref Collection Converter = Grooper.PgRefCollectionConverter
| Pg String Collection Converter = Grooper.PgStringCollectionConverter
| Border = Grooper.BorderExF
| License Checkout = Grooper.LicenseCheckout
| License Package = Grooper.LicensePackage
| Repository Connection = Grooper.DataSource
| Point ExF = Grooper.PointExF
| Line ExF = Grooper.LineExF
| Rectangle = Grooper.RectangleExF
| File Store Entry = Grooper.FileStoreEntry
| Folder = Grooper.Folder
| Object Library = Grooper.ObjectLibrary
| File Store = Grooper.FileStore
| Log Event = Grooper.LogEvent
| Machines = Grooper.MachinesFolder
| ODBC = Grooper.OdbcConnectionSettings
| Database Connection Settings = Grooper.DatabaseConnectionSettings
| Machine = Grooper.Machine
| Service Instance = Grooper.ServiceInstance
| SQL Server = Grooper.SqlConnectionSettings
| Database Row = Grooper.DatabaseRow
| System Config = Grooper.SystemConfig
| Property Converter = Grooper.PropertyConverter
| Simple Converter = Grooper.SimpleConverter
| SimpleConverter(Of Object Type, Property Type) = Grooper.SimpleConverter`2
| Time Range Converter = Grooper.TimeRangeConverter
| Time Ranges Converter = Grooper.TimeRangesConverter
| Times Converter = Grooper.TimesConverter
| Time Span Converter HMS = Grooper.TimeSpanConverterHMS
| Overlay = Grooper.IconName+Overlay
| ItemTypeConverter(Of Object Type) = Grooper.TypedCommand`1+ItemTypeConverter
| DCTModes = Grooper.JpegCompression+DCTModes
| HashAlgorithm = Grooper.HashBuilder+HashAlgorithm
| ACL Converter = Grooper.LDAP+ACLConverter
| ACL Editor = Grooper.LDAP+ACLEditor
| Quantity Converter = Grooper.ProductLicense+QuantityConverter
| Quantity Used Converter = Grooper.ProductLicense+QuantityUsedConverter
| Command Editor = Grooper.TypePermissions+CommandEditor
| Command Converter = Grooper.TypePermissions+CommandConverter
| Repository Info = Grooper.RemoteRepository+RepositoryInfo
| Pages = Grooper.PermissionSet+Pages
| Type Perms Editor = Grooper.PermissionSet+TypePermsEditor
| ControlKinds = Grooper.PropertyContext+ControlKinds
| Child Types Converter = Grooper.NodeInformation+ChildTypesConverter
| Props Editor = Grooper.NodeInformation+PropsEditor
| Value Converter = Grooper.NodeInformation+ValueConverter
| OperationType = Grooper.ClipboardData+OperationType
| Side = Grooper.PolarPoint+Side
| FileType = Grooper.GrooperImage+FileType
| SimplePixelFormat = Grooper.GrooperImage+SimplePixelFormat
| PixelFormat = Grooper.GrooperImage+PixelFormat
| PageOrientation = Grooper.GrooperImage+PageOrientation
| PropertyType = Grooper.IPropertyInfo+PropertyType
| UpdatabilityType = Grooper.IPropertyInfo+UpdatabilityType
| ProjectFileType = Grooper.VsiSession+ProjectFileType
| ProgrammingLanguages = Grooper.VsiSession+ProgrammingLanguages
| Script Info = Grooper.VsiSession+ScriptInfo
| MemberKind = Grooper.DataMemberInfo+MemberKind
| MemberFlags = Grooper.DataMemberInfo+MemberFlags
| CharacterCasing = Grooper.StringManager+CharacterCasing
| IxType = Grooper.DbCol+IxType
| Clear Children = Grooper.GrooperNode+ClearChildren
| Clone = Grooper.GrooperNode+CloneItem
| Delete = Grooper.GrooperNode+DeleteItem
| Rename = Grooper.GrooperNode+Rename
| Add = Grooper.GrooperNode+AddChild
| Move Up = Grooper.GrooperNode+MoveUp
| Move Down = Grooper.GrooperNode+MoveDown
| Add Multiple Items = Grooper.GrooperNode+AddMultipleItems
| Grooper Node Properties = Grooper.GrooperNode+GrooperNode_Properties
| NodeAttributes = Grooper.GrooperNode+NodeAttributes
| FieldMask = Grooper.GrooperNode+FieldMask
| InsertMethod = Grooper.GrooperNode+InsertMethod
| NodeFlags = Grooper.GrooperNode+NodeFlags
| Project Properties = Grooper.Project+Project_Properties
| Remove Empty Subfolders = Grooper.Project+RemoveEmptySubfolders
| Projects Converter = Grooper.Project+ProjectsConverter
| Projects Editor = Grooper.Project+ProjectsEditor
| System Maintenance = Grooper.GrooperRoot+SystemMaintenance
| Properties = Grooper.GrooperRoot+Properties
| License Url Converter = Grooper.GrooperRoot+LicenseUrlConverter
| Options Editor = Grooper.GrooperRoot+OptionsEditor
| Rename = Grooper.ResourceFile+Rename
| DisplayOptions = Grooper.ObjectCollectionEditor+DisplayOptions
| CodeIcon = Grooper.CompletionProvider+CodeIcon
| ConcurrencyMode = Grooper.ConcurrencyModeAttribute+ConcurrencyMode
| IconStyle = Grooper.IconResourceAttribute+IconStyle
| SHGFI = Grooper.NativeMethods+SHGFI
| Converter = Grooper.BorderExF+Converter
| License Collection Editor = Grooper.LicensePackage+LicenseCollectionEditor
| Short Date Converter = Grooper.LicensePackage+ShortDateConverter
| PackageStatus = Grooper.LicensePackage+PackageStatus
| LicenseeTypes = Grooper.LicensePackage+LicenseeTypes
| Converter = Grooper.PointExF+Converter
| LineOrientation = Grooper.LineExF+LineOrientation
| Converter = Grooper.RectangleExF+Converter
| Inches Converter = Grooper.RectangleExF+InchesConverter
| RETCODE = Grooper.ODBC32+RETCODE
| SQL_IDENTIFIER_CASE = Grooper.ODBC32+SQL_IDENTIFIER_CASE
| SQL_INFO = Grooper.ODBC32+SQL_INFO
| ServerTypes = Grooper.Database+ServerTypes
| Properties = Grooper.Folder+Properties
| Remove Empty Subfolders = Grooper.Folder+RemoveEmptySubfolders
| Properties = Grooper.ObjectLibrary+Properties
| Create Backup = Grooper.ObjectLibrary+CreateBackup
| Rename Script = Grooper.ObjectLibrary+RenameScript
| Properties = Grooper.FileStore+Properties
| Test Connection = Grooper.FileStore+TestConnection
| Move Objects Here = Grooper.FileStore+MoveObjectsHere
| Event Filter = Grooper.LogEvent+EventFilter
| Add Machine = Grooper.MachinesFolder+AddMachine
| Pg Odbc Dsn Converter = Grooper.OdbcConnectionSettings+PgOdbcDsnConverter
| Properties = Grooper.Machine+Properties
| Tune File System = Grooper.Machine+TuneFileSystem
| Database Name Editor = Grooper.SqlConnectionSettings+DatabaseNameEditor
| ConnectOptions = Grooper.GrooperDb+ConnectOptions
| ProcessingStatus = Grooper.GrooperDb+ProcessingStatus
| ProcessingScope = Grooper.GrooperDb+ProcessingScope
| EventType = Grooper.GrooperDb+EventType
| DatabaseStatus = Grooper.GrooperDb+DatabaseStatus
| Item Type Converter = Grooper.GrooperNode+AddMultipleItems+ItemTypeConverter
| Purge Folder = Grooper.GrooperRoot+SystemMaintenance+PurgeFolder
| Folder Editor = Grooper.GrooperRoot+SystemMaintenance+FolderEditor
| ResultOrder = Grooper.LogEvent+EventFilter+ResultOrder
| Culture Data = Grooper.Globalization.CultureData
| Base Culture Converter = Grooper.Globalization.BaseCultureConverter
| Base Culture Editor = Grooper.Globalization.BaseCultureEditor
| Culture Converter All = Grooper.Globalization.CultureConverterAll
| Culture Editor All = Grooper.Globalization.CultureEditorAll
| Culture Editor = Grooper.Globalization.CultureEditor
| Culture Converter = Grooper.Globalization.CultureConverter
| Language Converter = Grooper.Globalization.LanguageConverter
| Language Editor = Grooper.Globalization.LanguageEditor
| Base Multi Culture Converter = Grooper.Globalization.BaseMultiCultureConverter
| Multi Language Editor = Grooper.Globalization.MultiLanguageEditor
| Multi Language Converter = Grooper.Globalization.MultiLanguageConverter
| Multi Culture Converter = Grooper.Globalization.MultiCultureConverter
| Multi Culture Editor = Grooper.Globalization.MultiCultureEditor
| Annotation = Grooper.IP.Annotation
| Ellipse Annotation = Grooper.IP.EllipseAnnotation
| Filled Annotation = Grooper.IP.FilledAnnotation
| Line Annotation = Grooper.IP.LineAnnotation
| Polygon Annotation = Grooper.IP.PolygonAnnotation
| Rectangle Annotation = Grooper.IP.RectangleAnnotation
| Text Annotation = Grooper.IP.TextAnnotation
| Code39Settings = Grooper.IP.Code39Settings
| Data Matrix = Grooper.IP.DataMatrix
| Decoder = Grooper.IP.Decoder
| Intelligent Mail = Grooper.IP.IntelligentMail
| Postcode Decoder = Grooper.IP.PostcodeDecoder
| Postnet = Grooper.IP.Postnet
| Two Dimension Decoder = Grooper.IP.TwoDimensionDecoder
| Standard Reader = Grooper.IP.AtalaReader
| Barcode Reader = Grooper.IP.BarcodeReader
| One Dimension Decoder = Grooper.IP.OneDimensionDecoder
| Codabar = Grooper.IP.Codabar
| Code128 = Grooper.IP.Code128
| Code39 = Grooper.IP.Code39
| Pharmacode = Grooper.IP.Pharmacode
| 1D Reader = Grooper.IP.OneDimensionReader
| Postcode Reader = Grooper.IP.PostcodeReader
| 2D Reader = Grooper.IP.TwoDimensionReader
| AtalaIpCommand(Of Command Type) = Grooper.IP.AtalaIpCommand`1
| Color Stamp Detection = Grooper.IP.ColorStampDetection
| OCR Cleanup = Grooper.IP.OcrCleanup
| Mirror = Grooper.IP.Mirror
| Undistort = Grooper.IP.Undistort
| Dash Detector = Grooper.IP.DashDetector
| Edge Fixer = Grooper.IP.EdgeFixer
| IP Group = Grooper.IP.IpGroup
| IP Element = Grooper.IP.IpElement
| IP Step = Grooper.IP.IpStep
| IP Profile = Grooper.IP.IpProfile
| IP Element Container = Grooper.IP.IpElementContainer
| Border Detect = Grooper.IP.BorderDetect
| Contrast Stretch = Grooper.IP.ContrastStretch
| Barcode Detection = Grooper.IP.BarcodeDetection
| Binary Dropout = Grooper.IP.BinaryDropout
| Box Detection = Grooper.IP.BoxDetection
| Box Removal = Grooper.IP.BoxRemoval
| Line Removal = Grooper.IP.LineRemoval
| Shape Removal = Grooper.IP.ShapeRemoval
| Shade Removal = Grooper.IP.ShadeRemoval
| Scratch Removal = Grooper.IP.ScratchRemoval
| Auto Convert = Grooper.IP.AutoConvert
| Convert = Grooper.IP.Convert
| Extract Page = Grooper.IP.ExtractPage
| Warp = Grooper.IP.Warp
| Classify Image = Grooper.IP.ClassifyImage
| Execute Profile = Grooper.IP.ExecuteProfile
| Histogram = Grooper.IP.Histogram
| Auto Border Invert = Grooper.IP.AutoBorderInvert
| Auto Border Crop = Grooper.IP.AutoBorderCrop
| Compute Moments = Grooper.IP.ComputeMoments
| Corner Detection = Grooper.IP.CornerDetect
| Shape Detection = Grooper.IP.ShapeDetection
| Barcode Removal = Grooper.IP.BarcodeRemoval
| Feature Dropout = Grooper.IP.FeatureDropout
| Negative Region Removal = Grooper.IP.NegativeRegionRemoval
| Line Detection = Grooper.IP.LineDetection
| Binarize = Grooper.IP.Binarize
| Ip Command Result = Grooper.IP.IpCommandResult
| Region Detector = Grooper.IP.RegionDetector
| Sample Image Collection = Grooper.IP.SampleImageCollection
| Measurement = Grooper.IP.Measurement
| Unit Measurement = Grooper.IP.UnitMeasurement
| Logical Measurement = Grooper.IP.LogicalMeasurement
| Layout Object = Grooper.IP.LayoutObject
| Dropout Method = Grooper.IP.DropoutMethod
| Fill = Grooper.IP.Fill
| Inpaint = Grooper.IP.Inpaint
| Percent Range = Grooper.IP.PercentRange
| Double Range = Grooper.IP.DoubleRange
| Integer Range = Grooper.IP.IntegerRange
| Logical Border = Grooper.IP.LogicalBorder
| Logical Range = Grooper.IP.LogicalRange
| Logical Point = Grooper.IP.LogicalPoint
| Unit Range = Grooper.IP.UnitRange
| Logical Size = Grooper.IP.LogicalSize
| Logical Rectangle = Grooper.IP.LogicalRectangle
| Unit Line Length = Grooper.IP.UnitLineLength
| Unit Point = Grooper.IP.UnitPoint
| Unit Size = Grooper.IP.UnitSize
| Unit Rectangle = Grooper.IP.UnitRectangle
| Unit Border = Grooper.IP.UnitBorder
| JPEG 2000 = Grooper.IP.Jp2Compression
| Edge Detection = Grooper.IP.EdgeDetect
| Extract Channel = Grooper.IP.ExtractChannel
| Auto QA = Grooper.IP.AutoQA
| Measure Entropy = Grooper.IP.MeasureEntropy
| Projection Profile = Grooper.IP.ProjectionProfile
| Randomize Defects = Grooper.IP.RandomizeDefects
| Border Fill = Grooper.IP.BorderFill
| Crop = Grooper.IP.Crop
| Adjust Saturation = Grooper.IP.AdjustSaturation
| Adjust Tint = Grooper.IP.AdjustTint
| Auto Adjust Levels = Grooper.IP.AutoAdjustLevels
| Auto Color Balance = Grooper.IP.AutoColorBalance
| Auto White Balance = Grooper.IP.AutoWhiteBalance
| Brightness Contrast = Grooper.IP.BrightnessContrast
| Color Dropout = Grooper.IP.ColorDropout
| Colorize = Grooper.IP.Colorize
| Gamma Adjust = Grooper.IP.GammaAdjust
| Posterize = Grooper.IP.Posterize
| Solarize = Grooper.IP.Solarize
| Swap Channels = Grooper.IP.SwapChannels
| Blank Page Detection = Grooper.IP.BlankPageDetect
| Color Detection = Grooper.IP.ColorDetect
| Patch Code Detection = Grooper.IP.DetectPatchCodes
| Extract Features = Grooper.IP.ExtractFeatures
| Hough Lines = Grooper.IP.HoughLines
| Sticky Note Detection = Grooper.IP.StickyNoteDetection
| Threshold = Grooper.IP.Threshold
| Invert = Grooper.IP.Invert
| Blob Removal = Grooper.IP.BlobRemoval
| Dilate Erode = Grooper.IP.DilateErode
| Speck Removal = Grooper.IP.SpeckRemoval
| Filter = Grooper.IP.Filter
| Halftone Removal = Grooper.IP.HalftoneRemoval
| Hole Punch Removal = Grooper.IP.HolePunchRemoval
| Auto Deskew = Grooper.IP.AutoDeskew
| Resize = Grooper.IP.Resize
| Rotate = Grooper.IP.Rotate
| IP Command = Grooper.IP.IpCommand
| Layout Data = Grooper.IP.PageLayout
| TIFF Page = Grooper.IP.TifPage
| UnitType = Grooper.IP.Annotation+UnitType
| TrimOption = Grooper.IP.DataMatrix+TrimOption
| Code39Options = Grooper.IP.AtalaReader+Code39Options
| Pdf417Options = Grooper.IP.AtalaReader+Pdf417Options
| ReadingQuality = Grooper.IP.AtalaReader+ReadingQuality
| OneDimSymbology = Grooper.IP.OneDimensionReader+OneDimSymbology
| PostSymbology = Grooper.IP.PostcodeReader+PostSymbology
| TwoDimSymbology = Grooper.IP.TwoDimensionReader+TwoDimSymbology
| MaskShape = Grooper.IP.ImageMask+MaskShape
| Ip Element Properties = Grooper.IP.IpElement+IpElement_Properties
| Next Step Editor = Grooper.IP.IpElement+NextStepEditor
| Should Execute Editor = Grooper.IP.IpElement+ShouldExecuteEditor
| Ip Step Properties = Grooper.IP.IpStep+IpStep_Properties
| Command Editor = Grooper.IP.IpStep+CommandEditor
| Add Command = Grooper.IP.IpElementContainer+AddCommand
| ReadDirection = Grooper.IP.BarcodeDetection+ReadDirection
| Symbology = Grooper.IP.BarcodeDetection+Symbology
| Barcode Instance = Grooper.IP.BarcodeDetection+BarcodeInstance
| FilteringLevel = Grooper.IP.BoxDetection+FilteringLevel
| Box Info = Grooper.IP.BoxDetection+BoxInfo
| Image Class = Grooper.IP.ClassifyImage+ImageClass
| OperationType = Grooper.IP.AutoBorderInvert+OperationType
| DetectMethod = Grooper.IP.CornerDetect+DetectMethod
| CornerOrientation = Grooper.IP.CornerDetect+CornerOrientation
| Method = Grooper.IP.ShapeDetection+Method
| Shape Instance = Grooper.IP.ShapeDetection+ShapeInstance
| CombDetectionType = Grooper.IP.LineDetection+CombDetectionType
| HoughLevel = Grooper.IP.LineDetection+HoughLevel
| BinarizationMethod = Grooper.IP.Binarize+BinarizationMethod
| AdaptiveKernelType = Grooper.IP.Binarize+AdaptiveKernelType
| ConnectorKinds = Grooper.IP.LineDetector+ConnectorKinds
| Editor = Grooper.IP.SampleImageCollection+Editor
| Percent Range Converter = Grooper.IP.PercentRange+Converter
| Double Range Converter = Grooper.IP.DoubleRange+Converter
| Integer Range Converter = Grooper.IP.IntegerRange+Converter
| Logical Border Converter = Grooper.IP.LogicalBorder+Converter
| Arrow Converter = Grooper.IP.LogicalBorder+ArrowConverter
| Logical Point Converter = Grooper.IP.LogicalPoint+Converter
| Unit Range Converter = Grooper.IP.UnitRange+Converter
| Logical Size Converter = Grooper.IP.LogicalSize+Converter
| Logical Rectangle Converter = Grooper.IP.LogicalRectangle+Converter
| Simple Rectangle Converter = Grooper.IP.LogicalRectangle+SimpleConverter
| Unit Line Length Converter = Grooper.IP.UnitLineLength+Converter
| Unit Point Converter = Grooper.IP.UnitPoint+Converter
| Unit Size Converter = Grooper.IP.UnitSize+Converter
| Converter = Grooper.IP.UnitRectangle+Converter
| Unit Border Converter = Grooper.IP.UnitBorder+Converter
| Simple Value Converter = Grooper.IP.LogicalValue+SimpleConverter
| Universal Value Converter = Grooper.IP.LogicalValue+UniversalConverter
| Unit Value Converter = Grooper.IP.UnitValue+Converter
| ProgressionOrder = Grooper.IP.Jp2Compression+ProgressionOrder
| CompressionMode = Grooper.IP.Jp2Compression+CompressionMode
| Ratio Converter = Grooper.IP.Jp2Compression+RatioConverter
| ColorSpaceType = Grooper.IP.ExtractChannel+ColorSpaceType
| ChannelNumber = Grooper.IP.ExtractChannel+ChannelNumber
| MeasurementType = Grooper.IP.MeasureEntropy+MeasurementType
| Defect Generator = Grooper.IP.RandomizeDefects+DefectGenerator
| Border Generator = Grooper.IP.RandomizeDefects+BorderGenerator
| Noise Generator = Grooper.IP.RandomizeDefects+NoiseGenerator
| Image Skewer = Grooper.IP.RandomizeDefects+ImageSkewer
| Image Scaler = Grooper.IP.RandomizeDefects+ImageScaler
| Image Translator = Grooper.IP.RandomizeDefects+ImageTranslator
| BarCodeType = Grooper.IP.BarCodeGenerator+BarCodeType
| VerticalPosition = Grooper.IP.BarCodeGenerator+VerticalPosition
| FillMethod = Grooper.IP.BorderFill+FillMethod
| CropMethod = Grooper.IP.Crop+CropMethod
| CurveType = Grooper.IP.BrightnessContrast+CurveType
| FeatureType = Grooper.IP.ExtractFeatures+FeatureType
| AngleCategory = Grooper.IP.HoughLines+AngleCategory
| OperationType = Grooper.IP.DilateErode+OperationType
| FilterTypeEnum = Grooper.IP.Filter+FilterTypeEnum
| MaskTypeEnum = Grooper.IP.Filter+MaskTypeEnum
| ImageEdges = Grooper.IP.HolePunchRemoval+ImageEdges
| Precision Converter = Grooper.IP.AutoDeskew+PrecisionConverter
| SizeMethod = Grooper.IP.Resize+SizeMethod
| ResizeInterpolationMode = Grooper.IP.Resize+ResizeInterpolationMode
| WarpInterpolationMode = Grooper.IP.Rotate+WarpInterpolationMode
| ProcessingResolution = Grooper.IP.IpCommand+ProcessingResolution
| LogoVerticalPosition = Grooper.IP.PatchCodeGenerator+LogoVerticalPosition
| PatchCodeType = Grooper.IP.PatchCodeGenerator+PatchCodeType
| PixelFormatGroup = Grooper.IP.PixelFormatsAttribute+PixelFormatGroup
| ExifOrientation = Grooper.IP.ImageMetadata+ExifOrientation
| Jp2ColorSpace = Grooper.IP.NativeMethods+JP2+Jp2ColorSpace
| HpcCompOp = Grooper.IP.NativeMethods+HPC+HpcCompOp
| InpaintMethod = Grooper.IP.NativeMethods+HPC+InpaintMethod
| HarrisFilterType = Grooper.IP.NativeMethods+HPC+HarrisFilterType
| Connectivity = Grooper.IP.NativeMethods+HPC+Connectivity
| SegmentOptions = Grooper.IP.NativeMethods+HPC+SegmentOptions
| MaskSize = Grooper.IP.NativeMethods+HPC+MaskSize
| Axis = Grooper.IP.NativeMethods+HPC+Axis
| IppInterpolation = Grooper.IP.NativeMethods+HPC+IppInterpolation
| IppBorderType = Grooper.IP.NativeMethods+HPC+IppBorderType
| Ocr Item 0290 = Grooper.OCR.OcrItem_0290
| Ocr Results 0290 = Grooper.OCR.OcrResults_0290
| OCR Profile = Grooper.OCR.OcrProfile
| Auto Orient = Grooper.OCR.AutoOrient
| OCR Engine = Grooper.OCR.OcrEngine
| Tesseract OCR = Grooper.OCR.TesseractOcr
| Transym OCR 5 = Grooper.OCR.TransymOcr5
| Transym OCR Engine = Grooper.OCR.Transym
| Ocr Item = Grooper.OCR.OcrItem
| Ocr Results = Grooper.OCR.OcrResults
| Image Segmentation Options = Grooper.OCR.ImageSegmentationOptions
| Ocr Page Info = Grooper.OCR.OcrPageInfo
| OCR Repair Options = Grooper.OCR.OcrRepairOptions
| Transym OCR 4 = Grooper.OCR.TransymOcr
| Properties = Grooper.OCR.OcrProfile+Properties
| SynthesisMethodEnum = Grooper.OCR.OcrProfile+SynthesisMethodEnum
| DetectionMethod = Grooper.OCR.AutoOrient+DetectionMethod
| EngineModeEnum = Grooper.OCR.TesseractOcr+EngineModeEnum
| SegmentationModeEnum = Grooper.OCR.TesseractOcr+SegmentationModeEnum
| Tess Language Editor = Grooper.OCR.TesseractOcr+TessLanguageEditor
| Tess Language Converter = Grooper.OCR.TesseractOcr+TessLanguageConverter
| Seg Mode Converter = Grooper.OCR.TesseractOcr+SegModeConverter
| Special Fonts Converter = Grooper.OCR.TesseractOcr+SpecialFontsConverter
| CoordinateRelativityEnum = Grooper.OCR.TransymOcr5+CoordinateRelativityEnum
| BaseCharacterSetEnum = Grooper.OCR.TransymOcr5+BaseCharacterSetEnum
| LexMode = Grooper.OCR.TransymOcr5+LexMode
| AccuracyLevels = Grooper.OCR.TransymOcr5+AccuracyLevels
| PageOrientation = Grooper.OCR.TransymOcr5+PageOrientation
| Transym Language Editor = Grooper.OCR.TransymOcr5+TransymLanguageEditor
| Tansym Language Converter = Grooper.OCR.TransymOcr5+TansymLanguageConverter
| AvailableMetrics = Grooper.OCR.OcrItem+AvailableMetrics
| FontPitchMode = Grooper.OCR.OcrSegment+FontPitchMode
| PrintKind = Grooper.OCR.OcrSegment+PrintKind
| GlyphRegion = Grooper.OCR.CharData+GlyphRegion
| CharPosition = Grooper.OCR.CharData+CharPosition
| TopPosition = Grooper.OCR.CharData+TopPosition
| BottomPosition = Grooper.OCR.CharData+BottomPosition
| CoordinateRelativityEnum = Grooper.OCR.TransymOcr+CoordinateRelativityEnum
| PageOrientation = Grooper.OCR.TransymOcr+PageOrientation
| Pdf Font Name Converter = Grooper.PDF.PdfFontNameConverter
| PDF Burst Settings = Grooper.PDF.PdfBurstSettings
| PdfPermissions = Grooper.PDF.PdfPermissions
| PDF Render Settings = Grooper.PDF.PdfRenderSettings
| PDF Page Generator = Grooper.PDF.PdfPageGenerator
| PdfTextAlignment = Grooper.PDF.PdfAnnotation+PdfTextAlignment
| PdfBorderStyle = Grooper.PDF.PdfAnnotation+PdfBorderStyle
| ChoiceKind = Grooper.PDF.PdfChoiceWidget+ChoiceKind
| PageRotation = Grooper.PDF.PdfDoc+PageRotation
| Severity = Grooper.PDF.PdfRepairableFile+Severity
| TextRenderMode = Grooper.PDF.GraphicsState+TextRenderMode
| Categories = Grooper.PDF.DrawingOp+Categories
| PageTypes = Grooper.PDF.PdfPageInfo+PageTypes
| FitModes = Grooper.PDF.PdfBookmark+FitModes
| SearchableTextFormat = Grooper.PDF.PdfGenerator+SearchableTextFormat
| PdfDisplayMode = Grooper.PDF.PdfGenerator+PdfDisplayMode
| PdfViewerOptions = Grooper.PDF.PdfGenerator+PdfViewerOptions
| CompressionMode = Grooper.PDF.PdfSharpFile+CompressionMode
| ImageLayout = Grooper.PDF.PdfBurstSettings+ImageLayout
| ImageType = Grooper.PDF.PdfBurstSettings+ImageType
| TargetColorFormat = Grooper.PDF.PdfRenderSettings+TargetColorFormat
| PDFAComplianceLevels = Grooper.PDF.XmpData+PDFAComplianceLevels
| Batch = Grooper.Core.Batch
| Batches Folder = Grooper.Core.BatchesFolder
| Batch Folder = Grooper.Core.BatchFolder
| Batch Object = Grooper.Core.BatchObject
| Batch Page = Grooper.Core.BatchPage
| Batch Process = Grooper.Core.BatchProcess
| Batch Process Step = Grooper.Core.BatchProcessStep
| Content Category = Grooper.Core.ContentCategory
| Content Model = Grooper.Core.ContentModel
| Content Type = Grooper.Core.ContentType
| Document Type = Grooper.Core.DocumentType
| Form Type = Grooper.Core.FormType
| Page Type = Grooper.Core.PageType
| Training Page = Grooper.Core.TrainingPage
| Action List = Grooper.Core.ActionList
| Clear Item = Grooper.Core.ClearItem
| Append = Grooper.Core.Append
| Copy Base = Grooper.Core.CopyBase
| Copy = Grooper.Core.CopyItem
| Execute Rule = Grooper.Core.ExecuteRule
| Data Lookup = Grooper.Core.DataLookup
| Extract From = Grooper.Core.ExtractFrom
| Parse Value = Grooper.Core.ParseValue
| Concat = Grooper.Core.Concat
| Remove = Grooper.Core.Remove
| Require Value = Grooper.Core.RequireValue
| Raise Issue = Grooper.Core.RaiseIssue
| Calculate Value = Grooper.Core.SetFieldValue
| Data Action = Grooper.Core.DataAction
| Data Rule = Grooper.Core.DataRule
| Data Field Container = Grooper.Core.DataFieldContainer
| Data Element Container = Grooper.Core.DataElementContainer
| Data Column = Grooper.Core.DataColumn
| Data Element = Grooper.Core.DataElement
| Data Field = Grooper.Core.DataField
| Data Model = Grooper.Core.DataModel
| Data Section = Grooper.Core.DataSection
| Data Table = Grooper.Core.DataTable
| Extractor Node = Grooper.Core.ExtractorNode
| Data Connection = Grooper.Core.DataConnection
| Review Queue = Grooper.Core.ReviewQueue
| Processing Queue = Grooper.Core.ThreadPool
| Work Queue = Grooper.Core.WorkQueue
| Local Resources Folder = Grooper.Core.LocalResourcesFolder
| Doc Index = Grooper.Core.DocIndex
| Export Behavior = Grooper.Core.ExportBehavior
| Text Rendering = Grooper.Core.TextRendering
| ESP Classify Method = Grooper.Core.ESPClassifyMethod
| Run Child Extractors = Grooper.Core.RunChildExtractors
| Separate Action = Grooper.Core.SeparateAction
| Separation Provider = Grooper.Core.SeparationProvider
| Expression Set = Grooper.Core.ExpressionSet
| Data Fill Method = Grooper.Core.DataFillMethod
| Data Element Extension = Grooper.Core.DataElementExtension
| DataElementExtension(Of T Data Element) = Grooper.Core.DataElementExtension`1
| Field Value Lexicon = Grooper.Core.FieldValueLexicon
| Field Value List Provider = Grooper.Core.FieldValueListProvider
| Referenced Lexicon Provider = Grooper.Core.ReferencedLexiconProvider
| Expression Lexicon Provider = Grooper.Core.ExpressionLexiconProvider
| Classify Method = Grooper.Core.ClassifyMethod
| Lexical = Grooper.Core.Lexical
| Rules-Based = Grooper.Core.RulesBased
| Visual = Grooper.Core.Visual
| Classify Result = Grooper.Core.ClassifyResult
| Spell Corrector = Grooper.Core.SpellCorrector
| Auto Complete Settings = Grooper.Core.AutoCompleteSettings
| Multi Line Settings = Grooper.Core.MultiLineSettings
| Horizontal Tab Marker = Grooper.Core.HorizontalTabMarker
| Paragraph Marker = Grooper.Core.ParagraphMarker
| Vertical Tab Marker = Grooper.Core.VerticalTabMarker
| Number Names Provider = Grooper.Core.NumberNamesProvider
| Culture Info Provider = Grooper.Core.CultureInfoProvider
| Group Vocabulary Provider = Grooper.Core.GroupVocabularyProvider
| Vocabulary = Grooper.Core.VocabularyProvider
| Alpha Provider = Grooper.Core.AlphaProvider
| Number Provider = Grooper.Core.NumberProvider
| Variable Provider = Grooper.Core.VariableProvider
| Regular Expression = Grooper.Core.RegularExpression
| Virtual Table Definition = Grooper.Core.VirtualTableDefinition
| Database Schema Importer = Grooper.Core.DatabaseSchemaImporter
| Schema Importer = Grooper.Core.SchemaImporter
| Section Extract Method = Grooper.Core.SectionExtractMethod
| Table Extract Method = Grooper.Core.TableExtractMethod
| Data Element Profile = Grooper.Core.DataElementProfile
| Fuzzy Match Weightings = Grooper.Core.FuzzyMatchWeightings
| FRX Options = Grooper.Core.FrxOptions
| Line Snap Options = Grooper.Core.LineSnapOptions
| Result Snap Options = Grooper.Core.ResultSnapOptions
| Storage Type Numeric = Grooper.Core.StorageTypeNumeric
| Int64 = Grooper.Core.StorageTypeInt64
| Int32 = Grooper.Core.StorageTypeInt32
| Storage Type Ranged = Grooper.Core.StorageTypeRanged
| GUID = Grooper.Core.StorageTypeGUID
| Custom = Grooper.Core.StorageTypeCustom
| URL = Grooper.Core.StorageTypeURL
| String = Grooper.Core.StorageTypeString
| Int16 = Grooper.Core.StorageTypeInt16
| Double = Grooper.Core.StorageTypeDouble
| Decimal = Grooper.Core.StorageTypeDecimal
| DateTime = Grooper.Core.StorageTypeDateTime
| Boolean = Grooper.Core.StorageTypeBoolean
| Value Extractor = Grooper.Core.ValueExtractor
| Checkbox Instance = Grooper.Core.CheckBoxInstance
| Labeled Instance = Grooper.Core.FieldClassInstance
| Table Header Instance = Grooper.Core.TableHeaderInstance
| Section Instance Collection = Grooper.Core.SectionInstanceCollection
| Behavior = Grooper.Core.Behavior
| JSON Metadata = Grooper.Core.JsonMetadata
| KVP Metadata = Grooper.Core.KVPMetadata
| Merge Format = Grooper.Core.MergeFormat
| Delimited Metadata = Grooper.Core.DelimitedMetadata
| Metadata Format = Grooper.Core.MetadataFormat
| Bookmark Options = Grooper.Core.BookmarkOptions
| PDF Data Mapping = Grooper.Core.PDFGenerateBehavior
| Piece Info Options = Grooper.Core.PieceInfoOptions
| Metadata Options = Grooper.Core.MetadataOptions
| Simple Metadata = Grooper.Core.SimpleMetadata
| Text Format = Grooper.Core.TextFormat
| XML Metadata = Grooper.Core.XmlMetadata
| Import Behavior = Grooper.Core.ImportBehavior
| ZIP Format = Grooper.Core.ZIPFormat
| Batch Creation Settings = Grooper.Core.BatchCreationSettings
| Batch Name Settings = Grooper.Core.BatchNameSettings
| OPEX Import = Grooper.Core.OxiImport
| Import Definition = Grooper.Core.ImportDefinition
| Import Job = Grooper.Core.ImportJob
| Run Import = Grooper.Core.RunImport
| JPEG Image = Grooper.Core.JpegImage
| TIFF Document = Grooper.Core.TiffDocument
| Node Query = Grooper.Core.NodeQuery
| Code Expression = Grooper.Core.CodeExpression
| CodeExpression(Of Return Type) = Grooper.Core.CodeExpression`1
| String Expression = Grooper.Core.StringExpression
| Boolean Expression = Grooper.Core.BooleanExpression
| Path Expression = Grooper.Core.PathExpression
| Subfile Link = Grooper.Core.SubfileLink
| ZIP Link = Grooper.Core.ZipLink
| Publish To Repository = Grooper.Core.PublishToRepository
| Variable Definition = Grooper.Core.VariableDefinition
| Content Rendition = Grooper.Core.ContentRendition
| Folder Rendition = Grooper.Core.FolderRendition
| Text = Grooper.Core.TextRendition
| Page Rendition = Grooper.Core.PageRendition
| Database Lookup = Grooper.Core.DatabaseLookup
| Lexicon Lookup = Grooper.Core.LexiconLookup
| Attended Task Filter = Grooper.Core.AttendedTaskFilter
| Batch State = Grooper.Core.BatchState
| Processing Job = Grooper.Core.ProcessingJob
| Stats Query = Grooper.Core.StatsQuery
| Unattended Task Filter = Grooper.Core.UnattendedTaskFilter
| Data View = Grooper.Core.DataView
| Thumbnail View = Grooper.Core.ThumbnailView
| Folder View = Grooper.Core.HierarchyView
| Task View = Grooper.Core.TaskView
| Lookup Specification = Grooper.Core.LookupSpecification
| Attached File = Grooper.Core.NativeFormat
| Rendered Text = Grooper.Core.RenderedTextRendition
| Document Link = Grooper.Core.DocumentLink
| Folder Link = Grooper.Core.FolderLink
| Test Batch = Grooper.Core.TestBatchImport
| ZIP Archive = Grooper.Core.ZipHandler
| OCR Layer = Grooper.Core.OcrLayer
| Processing Task = Grooper.Core.ProcessingTask
| Attended Activity = Grooper.Core.AttendedActivity
| Layered OCR = Grooper.Core.LayeredOCR
| Lexicon = Grooper.Core.Lexicon
| PDF Format = Grooper.Core.PdfFormat
| Regex Property Editor = Grooper.Core.RegexPropertyEditor
| PDF Document = Grooper.Core.PdfMimeTypeHandler
| KVP Editor = Grooper.Core.KVPEditor
| Line Filter Converter = Grooper.Core.LineFilterConverter
| Ordered Reference Editor = Grooper.Core.NodeListEditor
| NodeListEditor(Of Node Type) = Grooper.Core.NodeListEditor`1
| Content Type Candidate = Grooper.Core.ContentTypeCandidate
| Page Classify Result = Grooper.Core.PageClassifyResult
| Text Preprocessor = Grooper.Core.TextPreprocessor
| Embedded Lexicon = Grooper.Core.EmbeddedLexicon
| Storage Type = Grooper.Core.StorageType
| Data Element Instance = Grooper.Core.DataElementInstance
| Data Instance = Grooper.Core.DataInstance
| Document Instance = Grooper.Core.DocumentInstance
| Element Container Instance = Grooper.Core.ElementContainerInstance
| Field Container Instance = Grooper.Core.FieldContainerInstance
| Field Instance = Grooper.Core.FieldInstance
| Section Instance = Grooper.Core.SectionInstance
| Simple Data Instance = Grooper.Core.SimpleDataInstance
| Table Cell Instance = Grooper.Core.TableCellInstance
| Table Instance = Grooper.Core.TableInstance
| Table Row Instance = Grooper.Core.TableRowInstance
| Text Line Instance = Grooper.Core.TextLineInstance
| Export Format = Grooper.Core.ExportFormat
| TIF Format = Grooper.Core.TifFormat
| Image = Grooper.Core.ImageRendition
| Attachment = Grooper.Core.NativeRendition
| Children = Grooper.Core.ChildrenRendition
| PDF = Grooper.Core.PdfRendition
| Content Link = Grooper.Core.ContentLink
| Export Definition = Grooper.Core.ExportDefinition
| File Export = Grooper.Core.FileExport
| File Import = Grooper.Core.FileImport
| File System Export = Grooper.Core.FileSystemExport
| File System Import = Grooper.Core.FileSystemImport
| File System Link = Grooper.Core.FileSystemLink
| Import Provider = Grooper.Core.ImportProvider
| Attachment Type = Grooper.Core.MimeTypeHandler
| Batch Filter = Grooper.Core.BatchFilter
| Activity = Grooper.Core.BatchProcessingActivity
| Task Filter = Grooper.Core.TaskFilter
| Code Activity = Grooper.Core.CodeActivity
| CodeActivity(Of Node Type) = Grooper.Core.CodeActivity`1
| Page Filter Converter = Grooper.Core.PageFilterConverter
| Batch Process Step Editor = Grooper.Core.BatchProcessStepEditor
| Content Scope Editor = Grooper.Core.ContentScopeEditor
| Content Type Editor = Grooper.Core.ContentTypeEditor
| Child Type Editor = Grooper.Core.ChildTypeEditor
| Content Types Editor = Grooper.Core.ContentTypesEditor
| Child Types Editor = Grooper.Core.ChildTypesEditor
| QueueConverter(Of Queue Type) = Grooper.Core.QueueConverter`1
| Test Batch Editor = Grooper.Core.TestBatchEditor
| String List Editor = Grooper.Core.StringListEditor
| Zone Editor = Grooper.Core.ZoneEditor
| Batch Properties = Grooper.Core.Batch+Batch_Properties
| Step Converter = Grooper.Core.Batch+StepConverter
| Archive = Grooper.Core.Batch+Archive
| Update Process = Grooper.Core.Batch+UpdateProcess
| Send To Production = Grooper.Core.Batch+SendToProduction
| Send To Test = Grooper.Core.Batch+SendToTest
| Combine = Grooper.Core.Batch+Combine
| Change Priority = Grooper.Core.Batch+ChangePriority
| Pause = Grooper.Core.Batch+Pause
| Resume = Grooper.Core.Batch+Resume
| Reset = Grooper.Core.Batch+Reset
| Remove Job History = Grooper.Core.Batch+RemoveJobHistory
| Batch Folder Properties = Grooper.Core.BatchFolder+BatchFolder_Properties
| Insert Folder = Grooper.Core.BatchFolder+InsertFolder
| Remove Level = Grooper.Core.BatchFolder+RemoveLevel
| Collapse = Grooper.Core.BatchFolder+Collapse
| New Text Document = Grooper.Core.BatchFolder+NewTextDocument
| Revert To Loose Pages = Grooper.Core.BatchFolder+RevertToLoosePages
| Sort Children = Grooper.Core.BatchFolder+SortChildren
| Classify Command = Grooper.Core.BatchFolder+ClassifyCommand
| Train As = Grooper.Core.BatchFolder+TrainAs
| Train From = Grooper.Core.BatchFolder+TrainFrom
| Extract = Grooper.Core.BatchFolder+Extract
| Assign Document Type = Grooper.Core.BatchFolder+AssignDocumentType
| Edit Type Assignment = Grooper.Core.BatchFolder+EditTypeAssignment
| Set Field Value = Grooper.Core.BatchFolder+SetFieldValue
| Batch Object Properties = Grooper.Core.BatchObject+BatchObject_Properties
| Empty Document = Grooper.Core.BatchObject+EmptyDocument
| BatchObjectCommand(Of Object Type) = Grooper.Core.BatchObject+BatchObjectCommand`1
| Create New Folder = Grooper.Core.BatchObject+CreateNewFolder
| Add Folder = Grooper.Core.BatchObject+AddFolder
| Merge Selected = Grooper.Core.BatchObject+MergeSelected
| Split Folder = Grooper.Core.BatchObject+SplitFolder
| Append To Previous = Grooper.Core.BatchObject+AppendToPrevious
| Prepend to Next = Grooper.Core.BatchObject+PrependToNext
| Send To Test Batch = Grooper.Core.BatchObject+SendToTestBatch
| Copy To Test Batch = Grooper.Core.BatchObject+CopyToTestBatch
| Move To Test Batch = Grooper.Core.BatchObject+MoveToTestBatch
| Flag Item = Grooper.Core.BatchObject+FlagCommand
| Clear Flag = Grooper.Core.BatchObject+ClearFlagCommand
| Rename = Grooper.Core.BatchObject+Rename
| Run Step = Grooper.Core.BatchObject+RunStep
| Run Activity = Grooper.Core.BatchObject+RunActivity
| Image Command = Grooper.Core.BatchPage+ImageCommand
| Display As Color = Grooper.Core.BatchPage+DisplayAsColor
| Display As Grayscale = Grooper.Core.BatchPage+DisplayAsGrayscale
| Display As Binary = Grooper.Core.BatchPage+DisplayAsBinary
| Reset = Grooper.Core.BatchPage+Reset
| Image Editing Command = Grooper.Core.BatchPage+ImageEditingCommand
| Rotate Left = Grooper.Core.BatchPage+RotateLeft
| Rotate Right = Grooper.Core.BatchPage+RotateRight
| Invert = Grooper.Core.BatchPage+Invert
| Undo Image Cleanup = Grooper.Core.BatchPage+UndoImageCleanup
| Image Review Command = Grooper.Core.BatchPage+ImageReviewCommand
| Apply Image Cleanup = Grooper.Core.BatchPage+ApplyCleanup
| Rasterize = Grooper.Core.BatchPage+Rasterize
| Generate Thumbnail = Grooper.Core.BatchPage+GenerateThumbnail
| Batch Page Properties = Grooper.Core.BatchPage+BatchPage_Properties
| Image Info = Grooper.Core.BatchPage+ImageInfo
| Page = Grooper.Core.BatchPage+DisplayImageRendition
| Text = Grooper.Core.BatchPage+TextBehindRendition
| Layout = Grooper.Core.BatchPage+LayoutRendition
| Add Activity = Grooper.Core.BatchProcess+AddActivity
| Publish = Grooper.Core.BatchProcess+Publish
| Unpublish = Grooper.Core.BatchProcess+Unpublish
| Create Project = Grooper.Core.BatchProcess+CreateProject
| Batch Process Properties = Grooper.Core.BatchProcess+BatchProcess_Properties
| Queue Converter = Grooper.Core.BatchProcess+QueueConverter
| Batch Process Step Properties = Grooper.Core.BatchProcessStep+BatchProcessStep_Properties
| ActivateModes = Grooper.Core.BatchProcessStep+ActivateModes
| Queue Converter = Grooper.Core.BatchProcessStep+QueueConverter
| Next Step Editor = Grooper.Core.BatchProcessStep+NextStepEditor
| Should Submit Editor = Grooper.Core.BatchProcessStep+ShouldSubmitEditor
| Processing Scope Converter = Grooper.Core.BatchProcessStep+ProcessingScopeConverter
| Content Model Properties = Grooper.Core.ContentModel+ContentModel_Properties
| Child Content Type Editor = Grooper.Core.ContentModel+ChildContentTypeEditor
| Content Type Properties = Grooper.Core.ContentType+ContentType_Properties
| Clean Overrides = Grooper.Core.ContentType+CleanOverrides
| Purge Training = Grooper.Core.ContentType+PurgeTraining
| Rebuild Training = Grooper.Core.ContentType+RebuildTraining
| Create Data Model = Grooper.Core.ContentType+CreateDataModel
| Create Local Resources Folder = Grooper.Core.ContentType+CreateLocalResourcesFolder
| Caption Editor = Grooper.Core.ContentType+CaptionEditor
| Unlimited Converter = Grooper.Core.ContentType+UnlimitedConverter
| Behaviors Converter = Grooper.Core.ContentType+BehaviorsConverter
| Behavior Collection Editor = Grooper.Core.ContentType+BehaviorCollectionEditor
| Parent Type Editor = Grooper.Core.ContentType+ParentTypeEditor
| ClassificationLevel = Grooper.Core.ContentType+ClassificationLevel
| TypeKind = Grooper.Core.ContentType+TypeKind
| Document Type Properties = Grooper.Core.DocumentType+DocumentType_Properties
| PaginationType = Grooper.Core.DocumentType+PaginationType
| TrainingScopes = Grooper.Core.DocumentType+TrainingScopes
| Form Type Properties = Grooper.Core.FormType+FormType_Properties
| Training Page Properties = Grooper.Core.TrainingPage+TrainingPage_Properties
| InstanceType = Grooper.Core.CopyBase+InstanceType
| Auto Map = Grooper.Core.CopyBase+AutoMap
| Trigger Editor = Grooper.Core.CopyBase+TriggerEditor
| Rule Editor = Grooper.Core.ExecuteRule+RuleEditor
| Pattern Editor = Grooper.Core.ParseValue+PatternEditor
| Trigger Editor = Grooper.Core.Concat+TriggerEditor
| Target Collection Editor = Grooper.Core.Concat+TargetCollectionEditor
| Trigger Editor = Grooper.Core.Remove+TriggerEditor
| Target Collection Editor = Grooper.Core.Remove+TargetCollectionEditor
| Required Elements Editor = Grooper.Core.RequireValue+RequiredElementsEditor
| Log Message Editor = Grooper.Core.RequireValue+LogMessageEditor
| Log Message Editor = Grooper.Core.RaiseIssue+LogMessageEditor
| Value Expression Editor = Grooper.Core.SetFieldValue+ValueExpressionEditor
| Action Element Editor = Grooper.Core.DataAction+ActionElementEditor
| Source Editor = Grooper.Core.DataAction+SourceEditor
| Target Editor = Grooper.Core.DataAction+TargetEditor
| Source Field Editor = Grooper.Core.DataAction+SourceFieldEditor
| Target Field Editor = Grooper.Core.DataAction+TargetFieldEditor
| Source Element Converter = Grooper.Core.DataAction+SourceElementConverter
| Target Element Converter = Grooper.Core.DataAction+TargetElementConverter
| Source Element Editor = Grooper.Core.DataAction+SourceElementEditor
| Target Element Editor = Grooper.Core.DataAction+TargetElementEditor
| Data Rule Properties = Grooper.Core.DataRule+DataRule_Properties
| Required Elements Editor = Grooper.Core.DataRule+RequiredElementsEditor
| Scope Editor = Grooper.Core.DataRule+ScopeEditor
| Trigger Editor = Grooper.Core.DataRule+TriggerEditor
| Data Field Container Properties = Grooper.Core.DataFieldContainer+DataFieldContainer_Properties
| Rule Editor = Grooper.Core.DataFieldContainer+RuleEditor
| Css Editor = Grooper.Core.DataFieldContainer+CssEditor
| Import Schema = Grooper.Core.DataFieldContainer+ImportSchema
| Data Element Container Properties = Grooper.Core.DataElementContainer+DataElementContainer_Properties
| Data Column Properties = Grooper.Core.DataColumn+DataColumn_Properties
| PropagationMode = Grooper.Core.DataColumn+PropagationMode
| FooterModes = Grooper.Core.DataColumn+FooterModes
| Data Element Properties = Grooper.Core.DataElement+DataElement_Properties
| Remove Overrides = Grooper.Core.DataElement+RemoveOverrides
| Display Label Converter = Grooper.Core.DataElement+DisplayLabelConverter
| Data Field Properties = Grooper.Core.DataField+DataField_Properties
| CalculateModes = Grooper.Core.DataField+CalculateModes
| Sub Element Converter = Grooper.Core.DataField+SubElementConverter
| Default Value Editor = Grooper.Core.DataField+DefaultValueEditor
| Field Expression Editor = Grooper.Core.DataField+FieldExpressionEditor
| Calculate Editor = Grooper.Core.DataField+CalculateEditor
| Validate Editor = Grooper.Core.DataField+ValidateEditor
| Validate Message Editor = Grooper.Core.DataField+ValidateMessageEditor
| Required Editor = Grooper.Core.DataField+RequiredEditor
| Data Model Properties = Grooper.Core.DataModel+DataModel_Properties
| Style Sheets Editor = Grooper.Core.DataModel+StyleSheetsEditor
| Data Section Properties = Grooper.Core.DataSection+DataSection_Properties
| Caption Editor = Grooper.Core.DataSection+CaptionEditor
| MissDispositions = Grooper.Core.DataSection+MissDispositions
| CaptureScope = Grooper.Core.DataSection+CaptureScope
| Data Table Properties = Grooper.Core.DataTable+DataTable_Properties
| Connection Command = Grooper.Core.DataConnection+ConnectionCommand
| Create Table = Grooper.Core.DataConnection+CreateTable
| Create Database = Grooper.Core.DataConnection+CreateDatabase
| Drop Table = Grooper.Core.DataConnection+DropTable
| Test Connection = Grooper.Core.DataConnection+TestConnection
| Properties = Grooper.Core.DataConnection+Properties
| Connection Converter = Grooper.Core.DataConnection+ConnectionConverter
| Table Name Editor = Grooper.Core.DataConnection+TableNameEditor
| Properties = Grooper.Core.ReviewQueue+Properties
| Properties = Grooper.Core.ThreadPool+Properties
| Size Converter = Grooper.Core.TextRendering+SizeConverter
| CalculateModes = Grooper.Core.ExpressionSet+CalculateModes
| Default Value Editor = Grooper.Core.ExpressionSet+DefaultValueEditor
| Field Expression Editor = Grooper.Core.ExpressionSet+FieldExpressionEditor
| Calculate Editor = Grooper.Core.ExpressionSet+CalculateEditor
| Validate Editor = Grooper.Core.ExpressionSet+ValidateEditor
| Validate Message Editor = Grooper.Core.ExpressionSet+ValidateMessageEditor
| Required Editor = Grooper.Core.ExpressionSet+RequiredEditor
| Included Descendants Editor = Grooper.Core.DataFillMethod+IncludedDescendantsEditor
| Included Children Editor = Grooper.Core.DataFillMethod+IncludedChildrenEditor
| ValueInterpretations = Grooper.Core.FieldValueLexicon+ValueInterpretations
| UserTrainingMode = Grooper.Core.AutoCompleteSettings+UserTrainingMode
| BrowserSuggestMode = Grooper.Core.AutoCompleteSettings+BrowserSuggestMode
| TabOptions = Grooper.Core.HorizontalTabMarker+TabOptions
| ParagraphOptions = Grooper.Core.ParagraphMarker+ParagraphOptions
| Month Names = Grooper.Core.CultureInfoProvider+MonthNames
| Month Names Genetive = Grooper.Core.CultureInfoProvider+MonthNamesGenetive
| Month Names Abbreviated = Grooper.Core.CultureInfoProvider+MonthNamesAbbreviated
| Day Names = Grooper.Core.CultureInfoProvider+DayNames
| Day Names Abbreviated = Grooper.Core.CultureInfoProvider+DayNamesAbbreviated
| Day Names Shortest = Grooper.Core.CultureInfoProvider+DayNamesShortest
| Digits = Grooper.Core.CultureInfoProvider+Digits
| Currency Symbols = Grooper.Core.CultureInfoProvider+CurrencySymbols
| Currency Labels = Grooper.Core.CultureInfoProvider+CurrencyLabels
| Currency Decimal Separators = Grooper.Core.CultureInfoProvider+CurrencyDecimalSeparators
| Currency Decimal Digits = Grooper.Core.CultureInfoProvider+CurrencyDecimalDigits
| Currency Group Separators = Grooper.Core.CultureInfoProvider+CurrencyGroupSeparators
| Currency Group Digits = Grooper.Core.CultureInfoProvider+CurrencyGroupDigits
| Letters = Grooper.Core.CultureInfoProvider+Letters
| Letters Upper = Grooper.Core.CultureInfoProvider+LettersUpper
| Letters Lower = Grooper.Core.CultureInfoProvider+LettersLower
| Group Converter = Grooper.Core.RegularExpression+GroupConverter
| Collection Editor = Grooper.Core.VirtualTableDefinition+CollectionEditor
| Columns Editor = Grooper.Core.VirtualTableDefinition+ColumnsEditor
| Input Styles Converter = Grooper.Core.StorageTypeNumeric+InputStylesConverter
| NumberFormats = Grooper.Core.StorageTypeNumeric+NumberFormats
| TokenType = Grooper.Core.LonghandNumberParser+TokenType
| Editor = Grooper.Core.ValueExtractor+Editor
| Converter = Grooper.Core.ValueExtractor+Converter
| Field List Editor = Grooper.Core.Behavior+FieldListEditor
| All Fields Converter = Grooper.Core.Behavior+AllFieldsConverter
| JsonLayout = Grooper.Core.JsonMetadata+JsonLayout
| Data Element Editor = Grooper.Core.BookmarkOptions+DataElementEditor
| Field Annotation = Grooper.Core.PDFGenerateBehavior+FieldAnnotation
| Highlight Annotation = Grooper.Core.PDFGenerateBehavior+HighlightAnnotation
| Text Annotation = Grooper.Core.PDFGenerateBehavior+TextAnnotation
| Field Widget Annotation = Grooper.Core.PDFGenerateBehavior+FieldWidgetAnnotation
| Signature Widget = Grooper.Core.PDFGenerateBehavior+SignatureWidget
| Textbox Widget = Grooper.Core.PDFGenerateBehavior+TextboxWidget
| Checkbox Widget = Grooper.Core.PDFGenerateBehavior+CheckboxWidget
| Radio Group Widget = Grooper.Core.PDFGenerateBehavior+RadioGroupWidget
| Font Name Converter = Grooper.Core.PDFGenerateBehavior+FontNameConverter
| Key Column Editor = Grooper.Core.PieceInfoOptions+KeyColumnEditor
| Value Column Editor = Grooper.Core.PieceInfoOptions+ValueColumnEditor
| Element Editor = Grooper.Core.PieceInfoOptions+ElementEditor
| Value Editor = Grooper.Core.MetadataOptions+ValueEditor
| Folder Level Info = Grooper.Core.BatchCreationSettings+FolderLevelInfo
| SegmentType = Grooper.Core.BatchNameSettings+SegmentType
| Converter = Grooper.Core.BatchNameSettings+Converter
| Content Mapping = Grooper.Core.OxiImport+ContentMapping
| OxiElement = Grooper.Core.OxiImport+OxiElement
| SideType = Grooper.Core.OxiImport+SideType
| ElementType = Grooper.Core.OxiImport+ElementType
| ImageType = Grooper.Core.OxiImport+ImageType
| Node Type Converter = Grooper.Core.NodeQuery+NodeTypeConverter
| Id Converter = Grooper.Core.NodeQuery+IdConverter
| Converter = Grooper.Core.CodeExpression+Converter
| Editor = Grooper.Core.CodeExpression+Editor
| Converter = Grooper.Core.PathExpression+Converter
| Editor = Grooper.Core.PathExpression+Editor
| Load Content = Grooper.Core.ZipLink+LoadContent
| Repository Converter = Grooper.Core.PublishToRepository+RepositoryConverter
| Repository Editor = Grooper.Core.PublishToRepository+RepositoryEditor
| Expression Editor = Grooper.Core.VariableDefinition+ExpressionEditor
| Variable Type Converter = Grooper.Core.VariableDefinition+VariableTypeConverter
| SQL Query Editor = Grooper.Core.DatabaseLookup+SQLQueryEditor
| Field Mapping = Grooper.Core.LexiconLookup+FieldMapping
| Lookup Field Converter = Grooper.Core.LexiconLookup+LookupFieldConverter
| Target Field Converter = Grooper.Core.LexiconLookup+TargetFieldConverter
| Name List Converter = Grooper.Core.StatsQuery+NameListConverter
| Name List Editor = Grooper.Core.StatsQuery+NameListEditor
| Stat Names Editor = Grooper.Core.StatsQuery+StatNamesEditor
| Process Names Editor = Grooper.Core.StatsQuery+ProcessNamesEditor
| Step Names Editor = Grooper.Core.StatsQuery+StepNamesEditor
| Activity Names Editor = Grooper.Core.StatsQuery+ActivityNamesEditor
| User Names Editor = Grooper.Core.StatsQuery+UserNamesEditor
| Machine Names Editor = Grooper.Core.StatsQuery+MachineNamesEditor
| TimeFrames = Grooper.Core.StatsQuery+TimeFrames
| GroupingColumn = Grooper.Core.StatsQuery+GroupingColumn
| SortColumns = Grooper.Core.StatsQuery+SortColumns
| SortDirections = Grooper.Core.StatsQuery+SortDirections
| ProcessingLevel = Grooper.Core.DataView+ProcessingLevel
| IP Profiles Editor = Grooper.Core.ThumbnailView+IPProfilesEditor
| Folder Level Options = Grooper.Core.HierarchyView+FolderLevelOptions
| Trigger Editor = Grooper.Core.LookupSpecification+TriggerEditor
| TriggerModes = Grooper.Core.LookupSpecification+TriggerModes
| PopulationMethod = Grooper.Core.LookupSpecification+PopulationMethod
| MissDispositions = Grooper.Core.LookupSpecification+MissDispositions
| ConflictDispositions = Grooper.Core.LookupSpecification+ConflictDispositions
| TfModes = Grooper.Core.TfIdfModel+TfModes
| IdfModes = Grooper.Core.TfIdfModel+IdfModes
| Update = Grooper.Core.ZipHandler+Update
| Unzip = Grooper.Core.ZipHandler+Unzip
| Unpackage = Grooper.Core.ZipHandler+Unpackage
| Lexicon Properties = Grooper.Core.Lexicon+Lexicon_Properties
| Lexicons Editor = Grooper.Core.Lexicon+LexiconsEditor
| Lexicon Link Code Editor = Grooper.Core.Lexicon+LexiconLinkCodeEditor
| Merge Training = Grooper.Core.Lexicon+MergeTraining
| Truncate = Grooper.Core.Lexicon+Truncate
| Intersect = Grooper.Core.Lexicon+Intersect
| Subtract = Grooper.Core.Lexicon+Subtract
| Normalize = Grooper.Core.Lexicon+Normalize
| PdfBuildOptions = Grooper.Core.PdfFormat+PdfBuildOptions
| Post Full Screen Converter = Grooper.Core.PdfFormat+PostFullScreenConverter
| Repair = Grooper.Core.PdfMimeTypeHandler+Repair
| Compact = Grooper.Core.PdfMimeTypeHandler+Compact
| Burst = Grooper.Core.PdfMimeTypeHandler+Burst
| PDF Expand Method = Grooper.Core.PdfMimeTypeHandler+PDFExpandMethod
| Fixed Page Count = Grooper.Core.PdfMimeTypeHandler+FixedPageCount
| Tag Based = Grooper.Core.PdfMimeTypeHandler+TagBased
| Bookmarks = Grooper.Core.PdfMimeTypeHandler+Bookmarks
| Page Piece = Grooper.Core.PdfMimeTypeHandler+PagePiece
| Function Info = Grooper.Core.SqlCompletionProvider+FunctionInfo
| Epi Instance = Grooper.Core.PageClassifyResult+EpiInstance
| Bullet Instance = Grooper.Core.PageClassifyResult+BulletInstance
| FormatOptions = Grooper.Core.FormatString+FormatOptions
| ControlCharacters = Grooper.Core.TextPreprocessor+ControlCharacters
| DedupMode = Grooper.Core.DataInstanceCollection+DedupMode
| CompareMode = Grooper.Core.DataInstanceCollection+CompareMode
| SortOrder = Grooper.Core.DataInstanceCollection+SortOrder
| SortDirection = Grooper.Core.DataInstanceCollection+SortDirection
| Sort Specification = Grooper.Core.DataInstanceCollection+SortSpecification
| Local Entries Editor = Grooper.Core.EmbeddedLexicon+LocalEntriesEditor
| AlignmentType = Grooper.Core.FuzzyMatrix+AlignmentType
| FuzzyMatchMode = Grooper.Core.FuzzyRegEx+FuzzyMatchMode
| LexiconOptions = Grooper.Core.LexicalDictionary+LexiconOptions
| LexiconType = Grooper.Core.LexicalDictionary+LexiconType
| Converter = Grooper.Core.StorageType+Converter
| TypeModes = Grooper.Core.StorageType+TypeModes
| Character Span = Grooper.Core.DataElementInstance+CharacterSpan
| PermFlags = Grooper.Core.DataInstance+PermFlags
| TempFlags = Grooper.Core.DataInstance+TempFlags
| ChangeKind = Grooper.Core.DocumentInstance+ChangeKind
| Legacy Rect = Grooper.Core.SimpleDataInstance+LegacyRect
| Collection Converter = Grooper.Core.ExportFormat+CollectionConverter
| Remove Link = Grooper.Core.ContentLink+RemoveLink
| ConflictResolution = Grooper.Core.ExportDefinition+ConflictResolution
| DuplicateFilenameResolution = Grooper.Core.FileSystemExport+DuplicateFilenameResolution
| Load Content = Grooper.Core.FileSystemLink+LoadContent
| Save Content = Grooper.Core.FileSystemLink+SaveContent
| Move File = Grooper.Core.FileSystemLink+MoveFile
| Copy File = Grooper.Core.FileSystemLink+CopyFile
| Delete File = Grooper.Core.FileSystemLink+DeleteFile
| Change File Attributes = Grooper.Core.FileSystemLink+ChangeAttributes
| Disposition Converter = Grooper.Core.ImportProvider+DispositionConverter
| DispositionType = Grooper.Core.ImportProvider+DispositionType
| Rename Attachment = Grooper.Core.MimeTypeHandler+RenameAttachment
| Change Extension = Grooper.Core.MimeTypeHandler+ChangeExtension
| Remove Attachment = Grooper.Core.MimeTypeHandler+RemoveAttachment
| Remove PDF Version = Grooper.Core.MimeTypeHandler+RemovePdfVersion
| Filter Converter = Grooper.Core.BatchFilter+FilterConverter
| Status Editor = Grooper.Core.BatchFilter+StatusEditor
| Process Editor = Grooper.Core.BatchFilter+ProcessEditor
| Step Editor = Grooper.Core.BatchFilter+StepEditor
| Activity Editor = Grooper.Core.BatchFilter+ActivityEditor
| Queue Converter = Grooper.Core.TaskFilter+QueueConverter
| Process Name Converter = Grooper.Core.TaskFilter+ProcessNameConverter
| Step Name Converter = Grooper.Core.TaskFilter+StepNameConverter
| Batch Editor = Grooper.Core.TaskFilter+BatchEditor
| Activity Name Converter = Grooper.Core.TaskFilter+ActivityNameConverter
| HashScope = Grooper.Core.CodeActivity+HashScope
| IssueDisposition = Grooper.Core.CodeActivity+IssueDisposition
| ProcessingResult = Grooper.Core.TaskProcessor+ProcessingResult
| Folder Editor = Grooper.Core.Batch+Archive+FolderEditor
| TimeGrouping = Grooper.Core.Batch+Archive+TimeGrouping
| Process Converter = Grooper.Core.Batch+UpdateProcess+ProcessConverter
| Step Converter = Grooper.Core.Batch+UpdateProcess+StepConverter
| TaskScope = Grooper.Core.Batch+Reset+TaskScope
| Step Converter = Grooper.Core.Batch+Reset+StepConverter
| Step Checklist Editor = Grooper.Core.Batch+Reset+StepChecklistEditor
| FolderRelativePosition = Grooper.Core.BatchFolder+InsertFolder+FolderRelativePosition
| SortOption = Grooper.Core.BatchFolder+SortChildren+SortOption
| SortDirections = Grooper.Core.BatchFolder+SortChildren+SortDirections
| TypeOperation = Grooper.Core.BatchFolder+EditTypeAssignment+TypeOperation
| ArrayActions = Grooper.Core.BatchFolder+SetFieldValue+ArrayActions
| Field Editor = Grooper.Core.BatchFolder+SetFieldValue+FieldEditor
| Value Converter = Grooper.Core.BatchFolder+SetFieldValue+ValueConverter
| DocTypeEditor(Of Object Type) = Grooper.Core.BatchObject+BatchObjectCommand`1+DocTypeEditor
| FolderRelativePosition = Grooper.Core.BatchObject+AddFolder+FolderRelativePosition
| Flag Reason Converter = Grooper.Core.BatchObject+SendToTestBatch+FlagReasonConverter
| Flag Reason Converter = Grooper.Core.BatchObject+FlagCommand+FlagReasonConverter
| Step Converter = Grooper.Core.BatchObject+RunStep+StepConverter
| Activity Converter = Grooper.Core.BatchObject+RunActivity+ActivityConverter
| Ip Profile Converter = Grooper.Core.BatchPage+ApplyCleanup+IpProfileConverter
| Property Name Converter = Grooper.Core.DataElement+RemoveOverrides+PropertyNameConverter
| CreateModes = Grooper.Core.DataConnection+CreateTable+CreateModes
| Statement Editor = Grooper.Core.DataConnection+CreateTable+StatementEditor
| Field Annotation Editor = Grooper.Core.PDFGenerateBehavior+FieldAnnotation+FieldAnnotationEditor
| ZIPDispositions = Grooper.Core.ZipHandler+Unzip+ZIPDispositions
| Relative = Grooper.Extract.RelativeAdjustment
| Nested Table = Grooper.Extract.NestedTable
| Line Periodicity Detector = Grooper.Extract.LinePeriodicityDetector
| Delimited Extract = Grooper.Extract.CsvExtract
| Fluid Layout = Grooper.Extract.FluidLayout
| Fixed Width = Grooper.Extract.FixedWidth
| Grid Layout Options = Grooper.Extract.GridLayoutOptions
| Tabular Layout Options = Grooper.Extract.TabularLayoutOptions
| Field Match = Grooper.Extract.FieldMatch
| Detect Signature = Grooper.Extract.DetectSignature
| Labeled Value = Grooper.Extract.LabeledValue
| Label Match = Grooper.Extract.LabelMatch
| OMR Extractor = Grooper.Extract.OMRExtractor
| Read Metadata = Grooper.Extract.ReadMetaData
| Select Page = Grooper.Extract.SelectPage
| Label Version = Grooper.Extract.LabelVersion
| Label Info = Grooper.Extract.LabelInfo
| Labeling Behavior = Grooper.Extract.LabelingBehavior
| Labelset-Based = Grooper.Extract.LabelsetBased
| Label Set = Grooper.Extract.LabelSet
| Text Document = Grooper.Extract.TextDocument
| Text Wrap Options = Grooper.Extract.TextWrapOptions
| Split = Grooper.Extract.SplitProvider
| AND = Grooper.Extract.AndProvider
| Array = Grooper.Extract.ArrayProvider
| Base Array Provider = Grooper.Extract.BaseArrayProvider
| Base Combining Provider = Grooper.Extract.BaseCombiningProvider
| Collation Provider = Grooper.Extract.CollationProvider
| Combine = Grooper.Extract.CombineProvider
| Key-Value List = Grooper.Extract.KeyValueList
| Key-Value Pair = Grooper.Extract.KeyValueProvider
| Multi-Column = Grooper.Extract.MultiColumnProvider
| Individual = Grooper.Extract.NormalProvider
| Ordered Array = Grooper.Extract.OrderedArrayProvider
| Pattern-Based = Grooper.Extract.PatternBasedProvider
| Data Type = Grooper.Extract.DataType
| Flow = Grooper.Extract.FlowLayoutProvider
| Horizontal = Grooper.Extract.HorizontalLayoutProvider
| Layout Provider = Grooper.Extract.LayoutProvider
| Vertical = Grooper.Extract.VerticalLayoutProvider
| OCR Reader = Grooper.Extract.OcrReader
| OMR Reader = Grooper.Extract.OmrReader
| Result Processor = Grooper.Extract.ResultProcessor
| Divider = Grooper.Extract.DividerSEM
| Absolute = Grooper.Extract.AbsoluteAdjustment
| Anchor = Grooper.Extract.AnchorAdjustment
| Edge Adjustment = Grooper.Extract.EdgeAdjustment
| Edge of Page = Grooper.Extract.EdgeOfPageAdjustment
| Fixed = Grooper.Extract.FixedSEM
| Simple = Grooper.Extract.FlowSEM
| Full Page = Grooper.Extract.FullPageSEM
| Geometric = Grooper.Extract.GeometricSEM
| Grid Layout = Grooper.Extract.GridLayout
| Row Match = Grooper.Extract.RowMatch
| Barcode Extractor = Grooper.Extract.BarcodeExtractor
| Find Barcode = Grooper.Extract.FindBarcode
| Highlight Zone = Grooper.Extract.HighlightZone
| Labeled OMR = Grooper.Extract.LabeledOMR
| Ordered OMR = Grooper.Extract.OrderedOMR
| Read Barcode = Grooper.Extract.ReadBarcode
| Read Zone = Grooper.Extract.ReadZone
| Reference = Grooper.Extract.ReferenceExtractor
| Zonal OMR = Grooper.Extract.ZonalOMR
| Place Zone = Grooper.Extract.PlaceZone
| Transaction Layout Detection = Grooper.Extract.TransactionLayoutDetection
| Transaction Detection = Grooper.Extract.TransactionSEM
| Tabular Layout = Grooper.Extract.TabularLayout
| Multiline Row Settings = Grooper.Extract.MultilineRowSettings
| Table Header Detector = Grooper.Extract.TableHeaderDetector
| Table Row Detector = Grooper.Extract.TableRowDetector
| Field Class = Grooper.Extract.FieldClass
| Constrained Wrap Options = Grooper.Extract.ConstrainedWrapOptions
| Environment Options = Grooper.Extract.EnvironmentOptions
| Vertical Wrap Detection = Grooper.Extract.VerticalWrapDetection
| Value Reader = Grooper.Extract.ValueReader
| Character Class Filter = Grooper.Extract.CharacterClassFilter
| Fuzzy Lookup Options = Grooper.Extract.FuzzyLookupOptions
| Group Options = Grooper.Extract.GroupOptions
| Horizontal Alignment Settings = Grooper.Extract.HorizontalAlignmentSettings
| Value Lookup = Grooper.Extract.ValueLookup
| Result Filter = Grooper.Extract.ResultFilter
| Result Set Options = Grooper.Extract.ResultSetOptions
| List Match = Grooper.Extract.ListMatch
| Pattern Match = Grooper.Extract.PatternMatch
| Text Match = Grooper.Extract.TextMatch
| Word Match = Grooper.Extract.WordMatch
| Anchor Definition = Grooper.Extract.AnchorDefinition
| Dynamic Region = Grooper.Extract.DynamicRegion
| Fixed Region = Grooper.Extract.FixedRegion
| Region Definition = Grooper.Extract.RegionDefinition
| Relative Region = Grooper.Extract.RelativeRegion
| Shape Region = Grooper.Extract.ShapeRegion
| Text Region = Grooper.Extract.TextRegion
| Table Converter = Grooper.Extract.NestedTable+TableConverter
| MappingType = Grooper.Extract.CsvExtract+MappingType
| ReadMethods = Grooper.Extract.GridLayoutOptions+ReadMethods
| RowDetectionMode = Grooper.Extract.TabularLayoutOptions+RowDetectionMode
| SecondaryExtractTrigger = Grooper.Extract.TabularLayoutOptions+SecondaryExtractTrigger
| SecondaryExtractMethod = Grooper.Extract.TabularLayoutOptions+SecondaryExtractMethod
| Field Editor = Grooper.Extract.FieldMatch+FieldEditor
| Field Variable = Grooper.Extract.FieldMatch+FieldVariable
| Direction = Grooper.Extract.OmrGroup+Direction
| Source Converter = Grooper.Extract.ReadMetaData+SourceConverter
| Property Name Converter = Grooper.Extract.ReadMetaData+PropertyNameConverter
| Parent Label Converter = Grooper.Extract.LabelInfo+ParentLabelConverter
| LabelLayout = Grooper.Extract.LabelInfo+LabelLayout
| Split = Grooper.Extract.TextDocument+Split
| Insert Page Breaks = Grooper.Extract.TextDocument+InsertPageBreaks
| Normalize = Grooper.Extract.TextDocument+Normalize
| Encoding Converter = Grooper.Extract.TextDocument+EncodingConverter
| Normalize Encoding Converter = Grooper.Extract.TextDocument+NormalizeEncodingConverter
| SplitPositionEnum = Grooper.Extract.SplitProvider+SplitPositionEnum
| CombineType = Grooper.Extract.BaseCombiningProvider+CombineType
| ConfidenceModes = Grooper.Extract.BaseCombiningProvider+ConfidenceModes
| Group Name Converter = Grooper.Extract.BaseCombiningProvider+GroupNameConverter
| GroupingType = Grooper.Extract.CombineProvider+GroupingType
| ReadDirection = Grooper.Extract.KeyValueProvider+ReadDirection
| Extractor Variable Provider = Grooper.Extract.PatternBasedProvider+ExtractorVariableProvider
| Pattern Editor = Grooper.Extract.PatternBasedProvider+PatternEditor
| Group Name Converter = Grooper.Extract.PatternBasedProvider+GroupNameConverter
| Data Type Properties = Grooper.Extract.DataType+DataType_Properties
| Convert To Value Reader = Grooper.Extract.DataType+ConvertToValueReader
| Collation Editor = Grooper.Extract.DataType+CollationEditor
| VerticalDataAlignment = Grooper.Extract.HorizontalLayoutProvider+VerticalDataAlignment
| HorizontalDataAlignment = Grooper.Extract.VerticalLayoutProvider+HorizontalDataAlignment
| OmrMode = Grooper.Extract.OmrReader+OmrMode
| OmrBoxDirection = Grooper.Extract.OmrReader+OmrBoxDirection
| AdjustmentMethod = Grooper.Extract.AnchorAdjustment+AdjustmentMethod
| ExecutionScope = Grooper.Extract.AnchorAdjustment+ExecutionScope
| Edge = Grooper.Extract.EdgeAdjustment+Edge
| Header Column Editor = Grooper.Extract.GridLayout+HeaderColumnEditor
| Row Alignment Settings = Grooper.Extract.RowMatch+RowAlignmentSettings
| TableRowAlignment = Grooper.Extract.RowMatch+TableRowAlignment
| RowMatchOptions = Grooper.Extract.RowMatch+RowMatchOptions
| Output Group Converter = Grooper.Extract.BarcodeExtractor+OutputGroupConverter
| OmrFlowDirection = Grooper.Extract.OrderedOMR+OmrFlowDirection
| Group Name Converter = Grooper.Extract.ReferenceExtractor+GroupNameConverter
| OMR Box = Grooper.Extract.ZonalOMR+OmrBox
| Field List Editor = Grooper.Extract.TransactionSEM+FieldListEditor
| TableStyles = Grooper.Extract.TabularLayout+TableStyles
| Field Class Properties = Grooper.Extract.FieldClass+FieldClass_Properties
| Context Zones Converter = Grooper.Extract.FieldClass+ContextZonesConverter
| Purge Training = Grooper.Extract.FieldClass+PurgeTraining
| CollationType = Grooper.Extract.FieldClass+CollationType
| ContextScopes = Grooper.Extract.FieldClass+ContextScopes
| CompassDirection = Grooper.Extract.FieldClass+CompassDirection
| FlowDirection = Grooper.Extract.FieldClass+FlowDirection
| CultureScopes = Grooper.Extract.EnvironmentOptions+CultureScopes
| Value Reader Properties = Grooper.Extract.ValueReader+ValueReader_Properties
| Convert To Data Type = Grooper.Extract.ValueReader+ConvertToDataType
| HorizontalDataAlignment = Grooper.Extract.HorizontalAlignmentSettings+HorizontalDataAlignment
| AlignmentMode = Grooper.Extract.HorizontalAlignmentSettings+AlignmentMode
| LookupOption = Grooper.Extract.ValueLookup+LookupOption
| ROIModes = Grooper.Extract.ResultFilter+ROIModes
| OutputValueOptions = Grooper.Extract.ResultSetOptions+OutputValueOptions
| WordTransform = Grooper.Extract.ResultSetOptions+WordTransform
| Sort Order Converter = Grooper.Extract.ResultSetOptions+SortOrderConverter
| Local Entries Editor = Grooper.Extract.ListMatch+LocalEntriesEditor
| List Match Entries = Grooper.Extract.ListMatch+ListMatchEntries
| Group Options Editor = Grooper.Extract.PatternMatch+GroupOptionsEditor
| Group Options Converter = Grooper.Extract.PatternMatch+GroupOptionsConverter
| Output Format Editor = Grooper.Extract.PatternMatch+OutputFormatEditor
| Reg Ex Editor = Grooper.Extract.TextMatch+RegExEditor
| Formatted Instance = Grooper.Extract.TextMatch+FormattedInstance
| Output Format Editor = Grooper.Extract.WordMatch+OutputFormatEditor
| Integer Range Converter = Grooper.Extract.WordMatch+IntegerRangeConverter
| Term Options Editor = Grooper.Extract.WordMatch+TermOptionsEditor
| Term Options Converter = Grooper.Extract.WordMatch+TermOptionsConverter
| ReferencePointPosition = Grooper.Extract.AnchorDefinition+ReferencePointPosition
| Location Editor = Grooper.Extract.AnchorDefinition+LocationEditor
| Group Children = Grooper.EDI.GroupChildren
| EDI File = Grooper.EDI.EDIFile
| EDI Text Rendition = Grooper.EDI.EDITextRendition
| Schema Mapping = Grooper.EDI.SchemaMapping
| EDI Schema Importer = Grooper.EDI.EDISchemaImporter
| Edi Schema = Grooper.EDI.EdiSchema
| Edi Code = Grooper.EDI.EdiCode
| Edi Loop Definition = Grooper.EDI.EdiLoopDefinition
| Edi Schema Element = Grooper.EDI.EdiSchemaElement
| Edi Field Definition = Grooper.EDI.EdiFieldDefinition
| Edi Segment Definition = Grooper.EDI.EdiSegmentDefinition
| XML File = Grooper.EDI.XmlFile
| XML Value Selector = Grooper.EDI.XMLValueSelector
| Query XML = Grooper.EDI.QueryXML
| XML Format = Grooper.EDI.XMLFormat
| XML Lookup = Grooper.EDI.XMLLookup
| XML Schema Importer = Grooper.EDI.XMLSchemaImporter
| Bundle = Grooper.EDI.EDIFile+Bundle
| Split Envelopes = Grooper.EDI.EDIFile+SplitEnvelopes
| Load Data = Grooper.EDI.EDIFile+LoadData
| Schema Name Converter = Grooper.EDI.SchemaMapping+SchemaNameConverter
| Edi837Kind = Grooper.EDI.TransactionSet+Edi837Kind
| NamingMethods = Grooper.EDI.EDISchemaImporter+NamingMethods
| X12Schema Converter = Grooper.EDI.EDISchemaImporter+X12SchemaConverter
| UsageKind = Grooper.EDI.EdiSchema+UsageKind
| Conditions = Grooper.EDI.EdiFieldDefinition+Conditions
| Condition XML = Grooper.EDI.XmlFile+ConditionXML
| Format = Grooper.EDI.XmlFile+Format
| Load Data = Grooper.EDI.XmlFile+LoadData
| Split = Grooper.EDI.XmlFile+Split
| Validate Schema = Grooper.EDI.XmlFile+ValidateSchema
| Target Field Converter = Grooper.EDI.XMLValueSelector+TargetFieldConverter
| Path Editor = Grooper.EDI.XMLValueSelector+PathEditor
| Selector Editor = Grooper.EDI.XMLLookup+SelectorEditor
| NamingMethods = Grooper.EDI.XMLSchemaImporter+NamingMethods
| AttachmentNamingMethods = Grooper.EDI.EDIFile+Bundle+AttachmentNamingMethods
| DataDisposition = Grooper.EDI.EDIFile+LoadData+DataDisposition
| Office Open XML = Grooper.Office.OfficeOpenXML
| Power Point Document = Grooper.Office.PowerPointDocument
| Excel Document = Grooper.Office.ExcelDocument
| Convert to CSV = Grooper.Office.ExcelToCsv
| Office Document = Grooper.Office.OfficeDocument
| Word Document = Grooper.Office.WordDocument
| PST File = Grooper.Office.PSTHandler
| PST Link = Grooper.Office.PstLink
| WdAlertLevel = Microsoft.Office.Interop.Word.WdAlertLevel
| WdExportCreateBookmarks = Microsoft.Office.Interop.Word.WdExportCreateBookmarks
| WdExportFormat = Microsoft.Office.Interop.Word.WdExportFormat
| WdExportItem = Microsoft.Office.Interop.Word.WdExportItem
| WdExportOptimizeFor = Microsoft.Office.Interop.Word.WdExportOptimizeFor
| WdExportRange = Microsoft.Office.Interop.Word.WdExportRange
| SaveMethod = Grooper.Office.ExcelToCsv+SaveMethod
| Convert to PDF = Grooper.Office.WordDocument+WordToPdf
| Burst = Grooper.Office.PSTHandler+Burst
| Load Content = Grooper.Office.PstLink+LoadContent
| Exchange = Grooper.Messaging.ExchangeBinding
| Base FTP Binding = Grooper.Messaging.BaseFtpBinding
| FTP = Grooper.Messaging.FtpBinding
| FileListStyle = Grooper.Messaging.FileListStyle
| FTP Export = Grooper.Messaging.FtpExport
| FTP Import = Grooper.Messaging.FtpImport
| FTP Link = Grooper.Messaging.FtpLink
| HTML Document = Grooper.Messaging.HTMLDocument
| HTML Document Base = Grooper.Messaging.HTMLDocumentBase
| HTTP Import = Grooper.Messaging.HTTPImport
| Query HTML = Grooper.Messaging.QueryHTML
| HTML = Grooper.Messaging.HtmlRendition
| HTML Source = Grooper.Messaging.HTMLSourceRendition
| Text Body = Grooper.Messaging.TextBody
| Mail = Grooper.Messaging.MailRendition
| HTTP Link = Grooper.Messaging.HTTPLink
| HTTP Resource = Grooper.Messaging.HTTPResource
| Hyperlink Selector = Grooper.Messaging.HyperlinkSelector
| IMAP = Grooper.Messaging.IMAPBinding
| Mail Export = Grooper.Messaging.MailExport
| Mail Import = Grooper.Messaging.MailImport
| Mail Link = Grooper.Messaging.MailLink
| Mail Message = Grooper.Messaging.MailMimeTypeHandler
| RFC822 Source = Grooper.Messaging.RFC822SourceRendition
| SFTP = Grooper.Messaging.SftpBinding
| SFTP Export = Grooper.Messaging.SftpExport
| SFTP Import = Grooper.Messaging.SftpImport
| SFTP Link = Grooper.Messaging.SftpLink
| SFTP Repository Configuration = Grooper.Messaging.SftpRepositoryConfiguration
| Send Mail = Grooper.Messaging.SendMail
| AddressType = Grooper.Messaging.AddressType
| EmailAddressType = Grooper.Messaging.EmailAddressType
| PhoneType = Grooper.Messaging.PhoneType
| vCard = Grooper.Messaging.VCardTypeHandler
| Exchange OAuth = Grooper.Messaging.ExchangeBinding+ExchangeOAuth
| Auth Method Converter = Grooper.Messaging.ExchangeBinding+AuthMethodConverter
| Rebuild Search Folder = Grooper.Messaging.ExchangeBinding+RebuildSearchFolder
| FTP Repository Configuration = Grooper.Messaging.FtpBinding+FtpRepositoryConfiguration
| Ftp Folder Editor = Grooper.Messaging.FtpExport+FtpFolderEditor
| Load Content = Grooper.Messaging.FtpLink+LoadContent
| Save Content = Grooper.Messaging.FtpLink+SaveContent
| Delete File = Grooper.Messaging.FtpLink+DeleteFile
| Convert to PDF = Grooper.Messaging.HTMLDocument+ConvertToPDF
| Condition HTML = Grooper.Messaging.HTMLDocument+ConditionHTML
| Convert To Text = Grooper.Messaging.HTMLDocument+ConvertToText
| SelectorKind = Grooper.Messaging.QueryHTML+SelectorKind
| Load Content = Grooper.Messaging.HTTPLink+LoadContent
| Rename Attachment = Grooper.Messaging.HTTPLink+RenameAttachment
| folder Editor = Grooper.Messaging.IMAPBinding+folderEditor
| Mail Folder Editor = Grooper.Messaging.MailExport+MailFolderEditor
| IMAP Query Editor = Grooper.Messaging.MailImport+IMAPQueryEditor
| Load Content = Grooper.Messaging.MailLink+LoadContent
| Expand Attachments = Grooper.Messaging.MailLink+ExpandAttachments
| Delete Message = Grooper.Messaging.MailLink+DeleteMessage
| Convert To RFC822 = Grooper.Messaging.MailMimeTypeHandler+ConvertToRFC822
| Expand Attachments = Grooper.Messaging.MailMimeTypeHandler+ExpandAttachments
| Ssh Folder Editor = Grooper.Messaging.SftpExport+SshFolderEditor
| Load Content = Grooper.Messaging.SftpLink+LoadContent
| Save Content = Grooper.Messaging.SftpLink+SaveContent
| Delete File = Grooper.Messaging.SftpLink+DeleteFile
| Template Editor = Grooper.Messaging.SendMail+TemplateEditor
| SearchKeywordType = Grooper.Messaging.IMapQueryCompletionProvider+SearchKeywordType
| Expand Photo = Grooper.Messaging.VCardTypeHandler+ExpandPhoto
| Orientation = Grooper.Messaging.HTMLDocument+ConvertToPDF+Orientation
| SaveAction = Grooper.Messaging.HTMLDocument+ConvertToPDF+SaveAction
| PaperKind = Grooper.Messaging.HTMLDocument+ConvertToPDF+PaperKind
| Wrap Rule = Grooper.Messaging.HTMLDocument+ConditionHTML+WrapRule
| Attribute Rule = Grooper.Messaging.HTMLDocument+ConditionHTML+AttributeRule
| BodyHandling = Grooper.Messaging.MailMimeTypeHandler+ExpandAttachments+BodyHandling
| Grooper Api Http Error = Grooper.Services.GrooperApiHttpError
| Specific Times = Grooper.Services.SpecificTimes
| Import Schedule = Grooper.Services.ImportSchedule
| Polling Loop = Grooper.Services.PollingLoop
| System Maintenance Service = Grooper.Services.SystemMaintenanceService
| Import Watcher = Grooper.Services.ImportWatcher
| Grooper Licensing = Grooper.Services.LicenseService
| Activity Processing = Grooper.Services.ActivityProcessing
| Timer Service = Grooper.Services.TimerService
| API Services = Grooper.Services.ApiServices
| Web Service = Grooper.Services.WebService
| Queue Converter = Grooper.Services.ActivityProcessing+QueueConverter
| DaysOfWeek = Grooper.Services.TimerService+DaysOfWeek
| Time Converter = Grooper.Services.TimerService+TimeConverter
| API Key = Grooper.Services.ApiServices+ApiKey
| AppXtender = Grooper.Services.CMIS.AxBinding
| FileBound = Grooper.Services.CMIS.FileboundBinding
| Extended Property Converter = Grooper.Services.CMIS.AxBinding+ExtendedPropertyConverter
| FileType = Grooper.Services.CMIS.AxBindingSoapConnector+FileType
| MergeAction = Grooper.Services.CMIS.AxBindingSoapConnector+MergeAction
| ContentMode = Grooper.Services.CMIS.AxBindingSoapConnector+ContentMode
| FormOverlayType = Grooper.Services.CMIS.AxBindingSoapConnector+FormOverlayType
| ConnectMethod = Grooper.Services.CMIS.FileboundBindingConnector+ConnectMethod
| Convert Data = Grooper.Activities.ConvertData
| Apply Rules = Grooper.Activities.ApplyRules
| Batch Transfer = Grooper.Activities.BatchTransfer
| Column Map = Grooper.Activities.ColumnMap
| Custom Statement = Grooper.Activities.CustomStatement
| Data Export = Grooper.Activities.DatabaseExportBehavior
| Return Value = Grooper.Activities.ReturnValue
| Table Mapping = Grooper.Activities.TableMapping
| Execute Command = Grooper.Activities.ExecuteCommand
| Execute Step = Grooper.Activities.ExecuteStep
| Execute Activity = Grooper.Activities.ExecuteActivity
| Export = Grooper.Activities.Export
| Fill Data = Grooper.Activities.FillData
| Shell Execute Info = Grooper.Activities.ShellExecuteInfo
| Route Definition = Grooper.Activities.RouteDefinition
| Route = Grooper.Activities.Route
| Text Transform = Grooper.Activities.TextTransform
| Detect Language (Legacy) = Grooper.Activities.DetectLanguage
| Execute = Grooper.Activities.Execute
| Merge = Grooper.Activities.Merge
| Recognize = Grooper.Activities.Recognize
| Remove Level = Grooper.Activities.RemoveLevel
| Split Pages = Grooper.Activities.SplitPages
| Split Text = Grooper.Activities.SplitText
| XML Transform = Grooper.Activities.XmlTransform
| Classification View = Grooper.Activities.ClassificationView
| Deduplicate = Grooper.Activities.Deduplicate
| Correct = Grooper.Activities.CorrectOCR
| Train Lexicon = Grooper.Activities.TrainLexicon
| Review = Grooper.Activities.Review
| Spawn Batch = Grooper.Activities.SpawnBatch
| Dispose Batch = Grooper.Activities.DisposeBatch
| Launch Process = Grooper.Activities.LaunchProcess
| Redact = Grooper.Activities.Redaction
| Render = Grooper.Activities.RenderDocument
| Classify = Grooper.Activities.ClassifyFolders
| Extract = Grooper.Activities.Extraction
| Image Processing = Grooper.Activities.ImageProcessing
| Separate = Grooper.Activities.Separation
| Separation View = Grooper.Activities.SeparationView
| SaveDisposition = Grooper.Activities.ConvertData+SaveDisposition
| Repository Converter = Grooper.Activities.BatchTransfer+RepositoryConverter
| Process Converter = Grooper.Activities.BatchTransfer+ProcessConverter
| Step Converter = Grooper.Activities.BatchTransfer+StepConverter
| Column Converter = Grooper.Activities.ColumnMap+ColumnConverter
| Expression Editor = Grooper.Activities.ColumnMap+ExpressionEditor
| Auto Map = Grooper.Activities.ColumnMap+AutoMap
| Statement Editor = Grooper.Activities.CustomStatement+StatementEditor
| Scope Editor = Grooper.Activities.CustomStatement+ScopeEditor
| Alternate Database Editor = Grooper.Activities.DatabaseExportBehavior+AlternateDatabaseEditor
| Field Editor = Grooper.Activities.ReturnValue+FieldEditor
| Column Editor = Grooper.Activities.ReturnValue+ColumnEditor
| MatchActions = Grooper.Activities.TableMapping+MatchActions
| Column Check List = Grooper.Activities.TableMapping+ColumnCheckList
| Scope Editor = Grooper.Activities.TableMapping+ScopeEditor
| Link Name Converter = Grooper.Activities.ExecuteCommand+LinkNameConverter
| Command Converter = Grooper.Activities.ExecuteCommand+CommandConverter
| Activity Converter = Grooper.Activities.ExecuteActivity+ActivityConverter
| SharedBehaviorModes = Grooper.Activities.Export+SharedBehaviorModes
| Name Converter = Grooper.Activities.FillData+NameConverter
| InitFlags = Grooper.Activities.DdeClient+InitFlags
| ExecuteType = Grooper.Activities.ShellExecuteInfo+ExecuteType
| Process Converter = Grooper.Activities.RouteDefinition+ProcessConverter
| Scope Editor = Grooper.Activities.TextTransform+ScopeEditor
| Record Editor = Grooper.Activities.TextTransform+RecordEditor
| Command Converter = Grooper.Activities.Execute+CommandConverter
| TextExtractMode = Grooper.Activities.Recognize+TextExtractMode
| OcrAssistMode = Grooper.Activities.Recognize+OcrAssistMode
| PageExtractMode = Grooper.Activities.SplitPages+PageExtractMode
| XmlSource = Grooper.Activities.XmlTransform+XmlSource
| XmlTarget = Grooper.Activities.XmlTransform+XmlTarget
| Transform Editor = Grooper.Activities.XmlTransform+TransformEditor
| DuplicateDisposition = Grooper.Activities.Deduplicate+DuplicateDisposition
| ComparisonMode = Grooper.Activities.Deduplicate+ComparisonMode
| RepairScope = Grooper.Activities.CorrectOCR+RepairScope
| Fields Editor = Grooper.Activities.CorrectOCR+FieldsEditor
| TrainingScope = Grooper.Activities.TrainLexicon+TrainingScope
| Scope Editor = Grooper.Activities.TrainLexicon+ScopeEditor
| View List Converter = Grooper.Activities.Review+ViewListConverter
| Command Options Editor = Grooper.Activities.Review+CommandOptionsEditor
| Command Options Converter = Grooper.Activities.Review+CommandOptionsConverter
| Command Options = Grooper.Activities.Review+CommandOptions
| SpawnMethod = Grooper.Activities.SpawnBatch+SpawnMethod
| ActionType = Grooper.Activities.SpawnBatch+ActionType
| FilterType = Grooper.Activities.SpawnBatch+FilterType
| BatchDisposition = Grooper.Activities.SpawnBatch+BatchDisposition
| BatchNameSuffixEnum = Grooper.Activities.SpawnBatch+BatchNameSuffixEnum
| Target Folder Editor = Grooper.Activities.DisposeBatch+TargetFolderEditor
| Extractors Editor = Grooper.Activities.Redaction+ExtractorsEditor
| Fields Editor = Grooper.Activities.Redaction+FieldsEditor
| BodyRenderingMethod = Grooper.Activities.RenderDocument+BodyRenderingMethod
| ProblemDisposition = Grooper.Activities.RenderDocument+ProblemDisposition
| ConvertMethod = Grooper.Activities.RenderDocument+ConvertMethod
| RenderResult = Grooper.Activities.RenderDocument+RenderResult
| ExecutionScope = Grooper.Activities.ClassifyFolders+ExecutionScope
| ReclassifyModes = Grooper.Activities.ClassifyFolders+ReclassifyModes
| Classification Level Converter = Grooper.Activities.ClassifyFolders+ClassificationLevelConverter
| Output Level Converter = Grooper.Activities.ClassifyFolders+OutputLevelConverter
| StatsLoggingMode = Grooper.Activities.Extraction+StatsLoggingMode
| ExtractMode = Grooper.Activities.Extraction+ExtractMode
| Data Element Filter Editor = Grooper.Activities.Extraction+DataElementFilterEditor
| Hot Keys Converter = Grooper.Activities.Review+CommandOptions+HotKeysConverter
| ColorTrac Scanner = Grooper.Capture.ColorTrac.ColorTracCaptureDevice
| Resolution Converter = Grooper.Capture.ColorTrac.ColorTracCaptureDevice+ResolutionConverter
| DataCompleteStatus = Grooper.Capture.ColorTrac.ColorTracScanner+DataCompleteStatus
| PaperJustification = Grooper.Capture.ColorTrac.ColorTracScanner+PaperJustification
| PaperEndCondition = Grooper.Capture.ColorTrac.ColorTracScanner+PaperEndCondition
| ThresholdMethod = Grooper.Capture.ColorTrac.ColorTracScanner+ThresholdMethod
| TurboMode = Grooper.Capture.ColorTrac.ColorTracScanner+TurboMode
| ScanSpeed = Grooper.Capture.ColorTrac.ColorTracScanner+ScanSpeed
| PageSizeMode = Grooper.Capture.ColorTrac.ColorTracScanner+PageSizeMode
| StandardPageSize = Grooper.Capture.ColorTrac.ColorTracScanner+StandardPageSize
| PaperStatus = Grooper.Capture.ColorTrac.ColorTracScanner+PaperStatus
| ButtonStatus = Grooper.Capture.ColorTrac.ColorTracScanner+ButtonStatus
| PaperSensorStatus = Grooper.Capture.ColorTrac.ColorTracScanner+PaperSensorStatus
| AutoPageSizeOption = Grooper.Capture.ColorTrac.ColorTracScanner+AutoPageSizeOption
| ColorFormat = Grooper.Capture.ColorTrac.ColorTracScanner+ColorFormat
| ScannerModel = Grooper.Capture.ColorTrac.ColorTracScanner+ScannerModel
| ScannerCommand = Grooper.Capture.ColorTrac.ColorTracScanner+ScannerCommand
| ScannerCommandOffset = Grooper.Capture.ColorTrac.ColorTracScanner+ScannerCommandOffset
| CMIS Binding = Grooper.CMIS.CmisBinding
| Custom Binding = Grooper.CMIS.CustomBinding
| NTFS = Grooper.CMIS.WindowsFileSystem
| CMIS = Grooper.CMIS.CmisServerBinding
| CMIS Compound Type = Grooper.CMIS.CMISCompoundType
| CMIS Type Reference = Grooper.CMIS.CMISTypeReference
| CMIS Folder Reference = Grooper.CMIS.CMISFolderReference
| Generate Local Type = Grooper.CMIS.GenerateLocalType
| Cmis Clipboard Data = Grooper.CMIS.CmisClipboardData
| CMIS Lookup = Grooper.CMIS.CmisLookup
| CMISQL Query = Grooper.CMIS.CmisQuery
| CMIS Type Definition = Grooper.CMIS.CmisTypeDefinition
| CMIS Boolean Property Definition = Grooper.CMIS.CmisPropertyBooleanDefinition
| CMIS DateTime Property Definition = Grooper.CMIS.CmisPropertyDateTimeDefinition
| CMIS Decimal Property Definition = Grooper.CMIS.CmisPropertyDecimalDefinition
| CMIS Property Definition = Grooper.CMIS.CmisPropertyDefinition
| CMIS HTML Property Definition = Grooper.CMIS.CmisPropertyHtmlDefinition
| CMIS ID Property Definition = Grooper.CMIS.CmisPropertyIdDefinition
| CMIS Integer Property Definition = Grooper.CMIS.CmisPropertyIntegerDefinition
| CMIS String Property Definition = Grooper.CMIS.CmisPropertyStringDefinition
| CMIS URI Property Definition = Grooper.CMIS.CmisPropertyUriDefinition
| CMIS Repository View = Grooper.CMIS.CmisRepositoryView
| AT_LEVEL Predicate = Grooper.CMIS.AtLevelPredicate
| Comparison Predicate = Grooper.CMIS.ComparisonPredicate
| CONTAINS Predicate = Grooper.CMIS.ContainsPredicate
| Predicate List = Grooper.CMIS.PredicateCollection
| IN Predicate = Grooper.CMIS.InPredicate
| MATCHES Predicate = Grooper.CMIS.MatchesPredicate
| ORDER BY Element = Grooper.CMIS.OrderByElement
| CMISQL Element = Grooper.CMIS.QueryElement
| Scope Predicate = Grooper.CMIS.ScopePredicate
| Select Element = Grooper.CMIS.SelectElement
| Join Clause = Grooper.CMIS.JoinClause
| Where Predicate = Grooper.CMIS.WherePredicate
| Azure OAuth = Grooper.CMIS.AzureOAuth
| OAuth Service Login = Grooper.CMIS.OAuthServiceLogin
| CMIS Export = Grooper.CMIS.CMISExportDefinition
| CMIS Schema Importer = Grooper.CMIS.CmisSchemaImporter
| CMIS Import = Grooper.CMIS.CMISImportDefinition
| CMIS Import Map = Grooper.CMIS.CMISImportMap
| CMIS Export Map = Grooper.CMIS.CMISExportMap
| Files Clipboard Data = Grooper.CMIS.FilesClipboardData
| Anonymous Authentication = Grooper.CMIS.AnonymousAuthentication
| Auto Authentication = Grooper.CMIS.AutoAuthentication
| Basic Authentication = Grooper.CMIS.BasicAuthentication
| HTTP Authentication Method = Grooper.CMIS.HttpAuthenticationMethod
| NTLM Authentication = Grooper.CMIS.NtlmAuthentication
| OAuth Authentication = Grooper.CMIS.OAuthAuthentication
| Image Clipboard Data = Grooper.CMIS.ImageClipboardData
| CMIS Folder Link = Grooper.CMIS.CmisFolderLink
| Cmis Import Base = Grooper.CMIS.CmisImportBase
| CMIS Import Base = Grooper.CMIS.CmisImportBase
| CMIS Document Link = Grooper.CMIS.CmisLink
| Import Descendants = Grooper.CMIS.ImportDescendants
| Import Query Results = Grooper.CMIS.ImportQueryResults
| CMIS Document = Grooper.CMIS.CmisDocument
| CMIS Folder = Grooper.CMIS.CmisFolder
| CMIS Object = Grooper.CMIS.CmisObject
| Nodes Clipboard Data = Grooper.CMIS.NodesClipboardData
| CMIS Connection = Grooper.CMIS.CmisConnection
| CMIS Repository = Grooper.CMIS.CmisRepository
| Secondary Types Editor = Grooper.CMIS.SecondaryTypesEditor
| Secondary Types Converter = Grooper.CMIS.SecondaryTypesConverter
| PdOptions = Grooper.CMIS.CustomBinding+PdOptions
| Repository Configuration = Grooper.CMIS.WindowsFileSystem+RepositoryConfiguration
| AuthenticationProvider = Grooper.CMIS.CmisServerBinding+AuthenticationProvider
| CmisProtocol = Grooper.CMIS.CmisServerBinding+CmisProtocol
| Editor = Grooper.CMIS.CMISCompoundType+Editor
| Converter(Of Instance Type) = Grooper.CMIS.CMISTypeReference+Converter`1
| Cmis Type Converter = Grooper.CMIS.CMISTypeReference+CmisTypeConverter
| Editor = Grooper.CMIS.CMISFolderReference+Editor
| Converter = Grooper.CMIS.CMISFolderReference+Converter
| Doc Type Property Converter = Grooper.CMIS.GenerateLocalType+DocTypePropertyConverter
| Property Check List = Grooper.CMIS.GenerateLocalType+PropertyCheckList
| Query Editor = Grooper.CMIS.CmisQuery+QueryEditor
| Primary Type Converter = Grooper.CMIS.CmisQuery+PrimaryTypeConverter
| Select Elements Converter = Grooper.CMIS.CmisQuery+SelectElementsConverter
| Joins Converter = Grooper.CMIS.CmisQuery+JoinsConverter
| Where Element Converter = Grooper.CMIS.CmisQuery+WhereElementConverter
| Comp Op Converter = Grooper.CMIS.ComparisonPredicate+CompOpConverter
| Value Converter = Grooper.CMIS.ComparisonPredicate+ValueConverter
| Predicate Collection Editor = Grooper.CMIS.PredicateCollection+PredicateCollectionEditor
| Logical Operator Converter = Grooper.CMIS.PredicateCollection+LogicalOperatorConverter
| In Predicate Values Converter = Grooper.CMIS.InPredicate+InPredicateValuesConverter
| OrderByDirection = Grooper.CMIS.OrderByElement+OrderByDirection
| Selectable Property Converter = Grooper.CMIS.QueryElement+SelectablePropertyConverter
| Queryable Property Converter = Grooper.CMIS.QueryElement+QueryablePropertyConverter
| Qrderable Property Converter = Grooper.CMIS.QueryElement+QrderablePropertyConverter
| Secondary Type Converter = Grooper.CMIS.JoinClause+SecondaryTypeConverter
| Creatable Child Type Converter = Grooper.CMIS.CMISExportDefinition+CreatableChildTypeConverter
| Creatable Folder Converter = Grooper.CMIS.CMISExportDefinition+CreatableFolderConverter
| NamingMethods = Grooper.CMIS.CmisSchemaImporter+NamingMethods
| Null Scope = Grooper.CMIS.CMISImportDefinition+NullScope
| OtherMappings = Grooper.CMIS.CMISImportMap+OtherMappings
| Field Converter = Grooper.CMIS.CMISImportMap+FieldConverter
| Expression Editor = Grooper.CMIS.CMISImportMap+ExpressionEditor
| Auto Map = Grooper.CMIS.CMISImportMap+AutoMap
| Column Converter = Grooper.CMIS.CMISExportMap+ColumnConverter
| Expression Editor = Grooper.CMIS.CMISExportMap+ExpressionEditor
| Auto Map = Grooper.CMIS.CMISExportMap+AutoMap
| Refresh Token Info = Grooper.CMIS.OAuthAuthentication+RefreshTokenInfo
| Login Editor = Grooper.CMIS.OAuthAuthentication+LoginEditor
| Login Converter = Grooper.CMIS.OAuthAuthentication+LoginConverter
| Load Children = Grooper.CMIS.CmisFolderLink+LoadChildrenCommand
| Load Pages = Grooper.CMIS.CmisFolderLink+LoadPages
| Load Properties = Grooper.CMIS.CmisFolderLink+LoadPropertiesCommand
| Save Properties = Grooper.CMIS.CmisFolderLink+SavePropertiesCommand
| Delete = Grooper.CMIS.CmisFolderLink+DeleteCommand
| LoadScope = Grooper.CMIS.CmisFolderLink+LoadScope
| ImportModes = Grooper.CMIS.CmisImportBase+ImportModes
| Load = Grooper.CMIS.CmisLink+Load
| Update = Grooper.CMIS.CmisLink+Update
| Save Version = Grooper.CMIS.CmisLink+SaveVersionCommand
| TransferScopes = Grooper.CMIS.CmisLink+TransferScopes
| Delete CMIS Document = Grooper.CMIS.CmisLink+DeleteCommand
| Move CMIS Document = Grooper.CMIS.CmisLink+Move
| Filter Editor = Grooper.CMIS.ImportDescendants+FilterEditor
| Choice Converter = Grooper.CMIS.CmisObject+ChoiceConverter
| PastePosition = Grooper.CMIS.NodesClipboardData+PastePosition
| Cmis Connection Properties = Grooper.CMIS.CmisConnection+CmisConnection_Properties
| Reset = Grooper.CMIS.CmisConnection+Reset
| Import Repository = Grooper.CMIS.CmisConnection+ImportRepository
| Cmis Repository Properties = Grooper.CMIS.CmisRepository+CmisRepository_Properties
| Reset = Grooper.CMIS.CmisRepository+Reset
| Repository Converter = Grooper.CMIS.CmisConnection+ImportRepository+RepositoryConverter
| Capture Device = Grooper.Capture.CaptureDevice
| Web Captured Page = Grooper.Capture.WebCapturedPage
| Import Device = Grooper.Capture.ImportDevice
| ISIS Device = Grooper.Capture.IsisDevice
| TWAIN Device = Grooper.Capture.TwainDevice
| Control Sheet = Grooper.Capture.ControlSheet
| Scanner Profile = Grooper.Capture.ScannerProfile
| Separation Profile = Grooper.Capture.SeparationProfile
| Capture Settings = Grooper.Capture.CaptureSettings
| Barcode Detected = Grooper.Capture.BarcodeDetected
| Blank Page Detected = Grooper.Capture.BlankPageDetected
| Content Type Detected = Grooper.Capture.ContentTypeDetected
| Page Count = Grooper.Capture.PageCount
| Separation Event = Grooper.Capture.SeparationEvent
| Shape Detected = Grooper.Capture.ShapeDetected
| ESP Separator = Grooper.Capture.ESPSeparator
| Event-Based = Grooper.Capture.EventBased
| Extractor Based Provider = Grooper.Capture.ExtractorBasedProvider
| Change In Value Separator = Grooper.Capture.ChangeInValueSeparator
| Control Sheet Separation = Grooper.Capture.ControlSheetSeparator
| EPI Separation = Grooper.Capture.EPISeparator
| ESP Auto Separation = Grooper.Capture.EspAutoSeparator
| Multi Separator = Grooper.Capture.MultiSeparator
| Pattern-Based Separation = Grooper.Capture.PatternBasedSeparator
| Real Time Provider = Grooper.Capture.RealTimeProvider
| Undo Separation = Grooper.Capture.UndoSeparationSeparator
| Generate Control Sheets = Grooper.Capture.GenerateControlSheets
| Page Attachment Rule = Grooper.Capture.PageAttachmentRule
| Scan Once Settings = Grooper.Capture.ScanOnceSettings
| Insert Control Sheets = Grooper.Capture.InsertControlSheets
| Scan View = Grooper.Capture.ScanView
| Separation Behavior = Grooper.Capture.SeparationBehavior
| ScanConditionType = Grooper.Capture.CaptureDevice+ScanConditionType
| PageSide = Grooper.Capture.CaptureDevice+PageSide
| Zip File Editor = Grooper.Capture.ImportDevice+ZipFileEditor
| ImportType = Grooper.Capture.ImportDevice+ImportType
| ScanningSpeed = Grooper.Capture.ImportDevice+ScanningSpeed
| Device Name Converter = Grooper.Capture.IsisDevice+DeviceNameConverter
| Device Name Converter = Grooper.Capture.TwainDevice+DeviceNameConverter
| Compression Mode Converter = Grooper.Capture.TwainDevice+CompressionModeConverter
| TwainCompressionModes = Grooper.Capture.TwainDevice+TwainCompressionModes
| Properties = Grooper.Capture.ControlSheet+Properties
| Properties = Grooper.Capture.ScannerProfile+Properties
| FeedOrientation = Grooper.Capture.ScannerProfile+FeedOrientation
| Properties = Grooper.Capture.SeparationProfile+Properties
| Preview Image Editor = Grooper.Capture.BarcodeDetected+PreviewImageEditor
| MissDispositionEnum = Grooper.Capture.ChangeInValueSeparator+MissDispositionEnum
| Binding Data = Grooper.Capture.ControlSheetSeparator+BindingData
| Document Types Editor = Grooper.Capture.GenerateControlSheets+DocumentTypesEditor
| PageDirection = Grooper.Capture.PageAttachmentRule+PageDirection
| Azure Document Intelligence OCR = Grooper.Cloud.AzureAI_OCR
| Box = Grooper.Cloud.BoxCMIS
| Analyze Photo = Grooper.Cloud.AnalyzePhoto
| Azure OCR = Grooper.Cloud.AzureOCR
| OneDrive = Grooper.Cloud.MicrosoftOneDrive
| Translate = Grooper.Cloud.Translate
| SharePoint = Grooper.Cloud.SharePoint
| Sp Base Item = Grooper.Cloud.SpBaseItem
| Sp Content Type = Grooper.Cloud.SpContentType
| Sp Field = Grooper.Cloud.SpField
| Sp File = Grooper.Cloud.SpFile
| Sp Folder = Grooper.Cloud.SpFolder
| Sp Library = Grooper.Cloud.SpLibrary
| Sp Library Item = Grooper.Cloud.SpLibraryItem
| Sp Site = Grooper.Cloud.SpSite
| Value Selector = Grooper.Cloud.ValueSelector
| Web Service Lookup = Grooper.Cloud.WebServiceLookup
| IBM FileNet Connector = Grooper.Cloud.FileNetBinding
| Model Editor = Grooper.Cloud.AzureAI_OCR+ModelEditor
| Language Converter = Grooper.Cloud.AzureAI_OCR+LanguageConverter
| AzureFeatures = Grooper.Cloud.AzureAIClient+AzureFeatures
| App Settings Editor = Grooper.Cloud.BoxCMIS+AppSettingsEditor
| MetadataModes = Grooper.Cloud.BoxCMIS+MetadataModes
| VisualFeatures = Grooper.Cloud.AzureComputerVision+VisualFeatures
| DomainDetails = Grooper.Cloud.AzureComputerVision+DomainDetails
| ApiRegionEnum = Grooper.Cloud.AzureComputerVision+ApiRegionEnum
| AzureLanguage = Grooper.Cloud.AzureComputerVision+AzureLanguage
| Language Converter = Grooper.Cloud.AzureOCR+LanguageConverter
| Api Version Converter = Grooper.Cloud.AzureOCR+ApiVersionConverter
| Model Version Converter = Grooper.Cloud.AzureOCR+ModelVersionConverter
| OneDrive OAuth = Grooper.Cloud.MicrosoftOneDrive+OneDriveOAuth
| ContentLayout = Grooper.Cloud.Translate+ContentLayout
| TranslateDisposition = Grooper.Cloud.Translate+TranslateDisposition
| Target Language Editor = Grooper.Cloud.Translate+TargetLanguageEditor
| Target Language Converter = Grooper.Cloud.Translate+TargetLanguageConverter
| Source Languages Editor = Grooper.Cloud.Translate+SourceLanguagesEditor
| Source Languages Converter = Grooper.Cloud.Translate+SourceLanguagesConverter
| SharePoint OAuth = Grooper.Cloud.SharePoint+SharePointOAuth
| Auth Method Converter = Grooper.Cloud.SharePoint+AuthMethodConverter
| Site Structure = Grooper.Cloud.SharePointClient+SiteStructure
| FieldTypeKind = Grooper.Cloud.SpField+FieldTypeKind
| EffectivePermissions = Grooper.Cloud.SpLibraryItem+EffectivePermissions
| Target Field Converter = Grooper.Cloud.ValueSelector+TargetFieldConverter
| MessageFormats = Grooper.Cloud.WebServiceLookup+MessageFormats
| HttpVerbs = Grooper.Cloud.WebServiceLookup+HttpVerbs
| Auth Method Converter = Grooper.Cloud.WebServiceLookup+AuthMethodConverter
| Url Editor = Grooper.Cloud.WebServiceLookup+UrlEditor
| Post Data Editor = Grooper.Cloud.WebServiceLookup+PostDataEditor
| Attachment Rule = Grooper.Core.AttachmentRule
| AI Search = Grooper.GPT.AISearch
| Update Search Index = Grooper.GPT.UpdateSearchIndex
| Remove From Index = Grooper.GPT.RemoveFromIndex
| Add To Index = Grooper.GPT.AddToIndex
| Delete Search Index = Grooper.GPT.DeleteSearchIndex
| Create Search Index = Grooper.GPT.CreateSearchIndex
| Submit Indexing Job = Grooper.GPT.SubmitIndexingJob
| Computed Field = Grooper.GPT.ComputedField
| Generated Query = Grooper.GPT.GeneratedQuery
| Index Stats = Grooper.GPT.IndexStats
| Field Filter = Grooper.GPT.FieldFilter
| HTTP Auth Method = Grooper.GPT.HTTPAuthMethod
| Basic = Grooper.GPT.Basic
| OAuth Client Credentials = Grooper.GPT.OAuthClientCredentials
| Mark Attachments = Grooper.GPT.MarkAttachments
| Attach = Grooper.GPT.Attach
| AI Separate = Grooper.GPT.AutoSeparate
| Detect Language = Grooper.GPT.DetectLanguage
| LLM Classifier = Grooper.GPT.LLMClassifier
| Search Classifier = Grooper.GPT.SearchClassifier
| AI Transaction Detection = Grooper.GPT.AITransactionDetection
| AI Collection Reader = Grooper.GPT.AICollectionReader
| AI Section Reader = Grooper.GPT.AISectionReader
| Fill Descendants = Grooper.GPT.FillDescendants
| Cluster Parameters = Grooper.GPT.ClusterParameters
| AI Assistant = Grooper.GPT.AIAssistant
| Chat Filter = Grooper.GPT.ChatFilter
| Bing Search = Grooper.GPT.BingSearchReference
| Resource Reference = Grooper.GPT.ResourceReference
| Search Index = Grooper.GPT.SearchIndexReference
| Bot Connector = Grooper.GPT.BotConnector
| AI Chat Filter = Grooper.GPT.AIChatFilter
| AI Chat = Grooper.GPT.AIChat
| AI Chat Settings = Grooper.GPT.AIChatSettings
| AI Message = Grooper.GPT.AIMessage
| Indexing Behavior = Grooper.GPT.IndexingBehavior
| Indexing Service = Grooper.GPT.IndexingService
| Index State = Grooper.GPT.IndexState
| Lucene Group = Grooper.GPT.LuceneGroup
| Lucene Phrase = Grooper.GPT.LucenePhrase
| Lucene Query = Grooper.GPT.LuceneQuery
| Lucene Word = Grooper.GPT.LuceneWord
| Saved Query = Grooper.GPT.SavedQuery
| Is Match Filter = Grooper.GPT.IsMatchFilter
| In Filter = Grooper.GPT.InFilter
| Lambda Filter = Grooper.GPT.LambdaFilter
| Boolean Filter = Grooper.GPT.BooleanFilter
| Comparison Filter = Grooper.GPT.ComparisonFilter
| Search Filter = Grooper.GPT.SearchFilter
| Search Import = Grooper.GPT.SearchImport
| Search License = Grooper.GPT.SearchLicense
| Search Index Query = Grooper.GPT.SearchIndexQuery
| Vector Search Options = Grooper.GPT.VectorSearchOptions
| AI Generated = Grooper.GPT.AIGenerated
| Start Fine Tuning Job = Grooper.GPT.StartFineTuningJob
| Delete Fine Tuned Model = Grooper.GPT.DeleteFineTunedModel
| Build Fine Tuning File = Grooper.GPT.BuildFineTuningFile
| Chunk Settings = Grooper.GPT.ChunkSettings
| AI Extract = Grooper.GPT.AIExtract
| AI Extract Table Options = Grooper.GPT.AIExtractTableOptions
| AI Extract Section Options = Grooper.GPT.AIExtractSectionOptions
| AI Extract Field Options = Grooper.GPT.AIExtractFieldOptions
| Chat Parameters = Grooper.GPT.ChatParameters
| Clause Detection = Grooper.GPT.ClauseDetection
| AI Table Reader = Grooper.GPT.AITableReader
| LLM License = Grooper.GPT.LLMLicense
| AI Generator = Grooper.GPT.AIGenerator
| Fill = Grooper.GPT.Fill
| GCS Provider = Grooper.GPT.GCSProvider
| Labeled Region = Grooper.GPT.LabeledRegion
| Layout Objects = Grooper.GPT.LayoutObjects
| Fine Tuning Service = Grooper.GPT.FineTuningService
| Embeddings Service = Grooper.GPT.EmbeddingsService
| Chat Service = Grooper.GPT.ChatService
| LLM Provider = Grooper.GPT.LLMProvider
| Azure Provider = Grooper.GPT.AzureProvider
| Service Deployment = Grooper.GPT.ServiceDeployment
| Open AI Provider = Grooper.GPT.OpenAIProvider
| Data Values = Grooper.GPT.DataValues
| Extracted = Grooper.GPT.Extracted
| Semantic = Grooper.GPT.Semantic
| GPT Embed = Grooper.GPT.GPTEmbed
| Quoting Method = Grooper.GPT.QuotingMethod
| LLM Connector = Grooper.GPT.OpenAIConnector
| Subset Filter = Grooper.GPT.SubsetFilter
| Retrieval Plan = Grooper.GPT.RetrievalPlan
| Ask User = Grooper.GPT.AskUser
| Bing Search = Grooper.GPT.BingSearch
| Retrieval Tool = Grooper.GPT.RetrievalTool
| Metadata Search = Grooper.GPT.MetadataSearch
| Load Schema = Grooper.GPT.LoadSchema
| Help Search = Grooper.GPT.HelpSearch
| Load Web Page = Grooper.GPT.LoadWebPage
| Web Service Call = Grooper.GPT.WebServiceCall
| Sql Query = Grooper.GPT.SqlQuery
| Vector Search = Grooper.GPT.VectorSearch
| Database Table = Grooper.GPT.TableReference
| Web Service = Grooper.GPT.WebServiceReference
| Wiki Search = Grooper.GPT.WikiSearch
| Ask AI = Grooper.GPT.OpenAI.Chat.AskAI
| AI Column Extractor = Grooper.GPT.OpenAI.Extractors.AIColumnExtractor
| Entity Recognition = Grooper.GPT.Azure.EntityRecognition
| Key Phrase Extraction = Grooper.GPT.Azure.KeyPhraseExtraction
| Pii Entity Recognition = Grooper.GPT.Azure.PiiEntityRecognition
| Text Analysis = Grooper.GPT.Azure.TextAnalysis
| Text Analysis Option = Grooper.GPT.Azure.TextAnalysisOption
| AttachmentPosition = Grooper.Core.AttachmentRule+AttachmentPosition
| Attach Info = Grooper.Core.AttachmentRule+AttachInfo
| Api Version Converter = Grooper.GPT.AISearch+ApiVersionConverter
| Service Stats = Grooper.GPT.AISearch+ServiceStats
| Index Name Converter = Grooper.GPT.RemoveFromIndex+IndexNameConverter
| IndexAction = Grooper.GPT.AddToIndex+IndexAction
| FieldFlags = Grooper.GPT.CreateSearchIndex+FieldFlags
| IndexOperations = Grooper.GPT.SubmitIndexingJob+IndexOperations
| Select Editor = Grooper.GPT.SubmitIndexingJob+SelectEditor
| Expression Editor = Grooper.GPT.ComputedField+ExpressionEditor
| Field Type Converter = Grooper.GPT.ComputedField+FieldTypeConverter
| Test = Grooper.GPT.OAuthClientCredentials+Test
| Filter Editor = Grooper.GPT.SearchClassifier+FilterEditor
| Response Data = Grooper.GPT.AITransactionDetection+ResponseData
| Anchor = Grooper.GPT.AITransactionDetection+Anchor
| Included Descendants Editor = Grooper.GPT.AISectionReader+IncludedDescendantsEditor
| Name Converter = Grooper.GPT.FillDescendants+NameConverter
| AI Assistant Properties = Grooper.GPT.AIAssistant+AIAssistant_Properties
| DocumentLinkingOptions = Grooper.GPT.AIAssistant+DocumentLinkingOptions
| RetrievalOptions = Grooper.GPT.AIAssistant+RetrievalOptions
| Search Index Editor = Grooper.GPT.AIAssistant+SearchIndexEditor
| ResultOrder = Grooper.GPT.ChatFilter+ResultOrder
| User Name Converter = Grooper.GPT.ChatFilter+UserNameConverter
| User Id Converter = Grooper.GPT.ChatFilter+UserIdConverter
| Index Name Converter = Grooper.GPT.SearchIndexReference+IndexNameConverter
| Filter Editor = Grooper.GPT.SearchIndexReference+FilterEditor
| Generate Subsets = Grooper.GPT.SearchIndexReference+GenerateSubsets
| Index Converter = Grooper.GPT.AIChatFilter+IndexConverter
| Filter Editor = Grooper.GPT.AIChatFilter+FilterEditor
| Delete = Grooper.GPT.AIChat+DeleteChat
| Rename = Grooper.GPT.AIChat+Rename
| BuiltInFieldKinds = Grooper.GPT.IndexingBehavior+BuiltInFieldKinds
| Included Elements Editor = Grooper.GPT.IndexingBehavior+IncludedElementsEditor
| BooleanOperator = Grooper.GPT.LuceneGroup+BooleanOperator
| Delete = Grooper.GPT.SavedQuery+DeleteQuery
| Rename = Grooper.GPT.SavedQuery+Rename
| QueryTypes = Grooper.GPT.IsMatchFilter+QueryTypes
| SearchModes = Grooper.GPT.IsMatchFilter+SearchModes
| LambdaFunction = Grooper.GPT.LambdaFilter+LambdaFunction
| BooleanOperator = Grooper.GPT.BooleanFilter+BooleanOperator
| ComparisonOperator = Grooper.GPT.ComparisonFilter+ComparisonOperator
| OperandTypes = Grooper.GPT.ComparisonFilter+OperandTypes
| Function Name Converter = Grooper.GPT.ComparisonFilter+FunctionNameConverter
| Operand Type Converter = Grooper.GPT.ComparisonFilter+OperandTypeConverter
| Value Type Converter = Grooper.GPT.ComparisonFilter+ValueTypeConverter
| OperationType = Grooper.GPT.SearchImport+OperationType
| ResultSetScope = Grooper.GPT.SearchIndexQuery+ResultSetScope
| Index Name Converter = Grooper.GPT.SearchIndexQuery+IndexNameConverter
| Search Editor = Grooper.GPT.SearchIndexQuery+SearchEditor
| Filter Editor = Grooper.GPT.SearchIndexQuery+FilterEditor
| Order By Editor = Grooper.GPT.SearchIndexQuery+OrderByEditor
| Model Editor = Grooper.GPT.StartFineTuningJob+ModelEditor
| Model Editor = Grooper.GPT.DeleteFineTunedModel+ModelEditor
| Models Editor = Grooper.GPT.DeleteFineTunedModel+ModelsEditor
| Fill Method Converter = Grooper.GPT.BuildFineTuningFile+FillMethodConverter
| Batch Editor = Grooper.GPT.BuildFineTuningFile+BatchEditor
| RowAlignMode = Grooper.GPT.AIExtractTableOptions+RowAlignMode
| SectionAlignMode = Grooper.GPT.AIExtractSectionOptions+SectionAlignMode
| FieldAlignMode = Grooper.GPT.AIExtractFieldOptions+FieldAlignMode
| Included Columns Editor = Grooper.GPT.AITableReader+IncludedColumnsEditor
| Fill Method Converter = Grooper.GPT.Fill+FillMethodConverter
| AuthorizationMethod = Grooper.GPT.ServiceDeployment+AuthorizationMethod
| Semantic Quoting Query = Grooper.GPT.Semantic+SemanticQuotingQuery
| Embeddings Model Editor = Grooper.GPT.GPTEmbed+EmbeddingsModelEditor
| Chat Model Editor = Grooper.GPT.OpenAIConnector+ChatModelEditor
| Embeddings Model Editor = Grooper.GPT.OpenAIConnector+EmbeddingsModelEditor
| Filter Editor = Grooper.GPT.SubsetFilter+FilterEditor
| RetrievalScope = Grooper.GPT.MetadataSearch+RetrievalScope
| QueryKinds = Grooper.GPT.SqlQuery+QueryKinds
| ResultKinds = Grooper.GPT.SqlQuery+ResultKinds
| Table Name Converter = Grooper.GPT.TableReference+TableNameConverter
| Definition File Editor = Grooper.GPT.WebServiceReference+DefinitionFileEditor
| Header Editor = Grooper.GPT.WebServiceReference+HeaderEditor
| OverflowDispositions = Grooper.GPT.OpenAI.Chat.AskAI+OverflowDispositions
| Schema Editor = Grooper.GPT.OpenAI.Chat.AskAI+SchemaEditor
| TextAnalysisKind = Grooper.GPT.Azure.TextAnalysis+TextAnalysisKind
| Entity Type Editor = Grooper.GPT.Azure.TextAnalysis+EntityTypeEditor
| Field Editor = Grooper.GPT.SearchIndexReference+GenerateSubsets+FieldEditor
| Burst Book = Grooper.Microform.BurstBook
| Margin Detector = Grooper.Microform.MarginDetector
| Clip Frames = Grooper.Microform.ClipFrames
| Fiche Card Layout = Grooper.Microform.FicheCardLayout
| Fiche Strip = Grooper.Microform.FicheStrip
| Fiche Frame = Grooper.Microform.FicheFrame
| Fiche Strip View = Grooper.Microform.FicheStripView
| Detect Frames = Grooper.Microform.DetectFrames
| Initialize Card = Grooper.Microform.SortTiles
| imageTypes = Grooper.Microform.BurstBook+imageTypes
| Article = Grooper.Help.Article
| Create Batch = GrooperReview.Objects.CreateBatch
| Create Review Batch = GrooperReview.Objects.CreateReviewBatch
| UI Command = GrooperReview.Objects.JsCommand
| JsCommand(Of Item Type, Model Type) = GrooperReview.Objects.JsCommand`2
| Stats Kiosk Settings = GrooperReview.Pages.Stats.StatsKioskSettings
| Job Filter = GrooperReview.Pages.Jobs.JobFilter
| Create Help Index = GrooperReview.Pages.Search.CreateHelpIndex
| Assistant Chat = GrooperReview.Pages.Search.AssistantChat
| Create Batch = GrooperReview.Pages.Search.CreateBatch
| Download Format = GrooperReview.Pages.Search.DownloadFormat
| Download Custom = GrooperReview.Pages.Search.DownloadCustom
| Download = GrooperReview.Pages.Search.Download
| Download CSV = GrooperReview.Pages.Search.DownloadCSV
| Download ZIP = GrooperReview.Pages.Search.DownloadZIP
| Download PDF = GrooperReview.Pages.Search.DownloadPDF
| Submit Job = GrooperReview.Pages.Search.SubmitJob
| Search Command = GrooperReview.Pages.Search.SearchCommand
| Test Search = GrooperReview.Pages.Design.TestSearch
| Processed Text = GrooperReview.DocView.ProcessedTextRendition
| Rubberband Header = GrooperReview.DataGrid.RubberbandHeader
| Rubberband Header Label = GrooperReview.DataGrid.RubberbandHeaderLabel
| Append Record = GrooperReview.DataGrid.AppendRecord
| Record Command = GrooperReview.DataGrid.RecordCommand
| Insert Record = GrooperReview.DataGrid.InsertRecord
| Delete Record = GrooperReview.DataGrid.DeleteRecord
| Merge With Previous = GrooperReview.DataGrid.MergeWithPrevious
| Move Previous = GrooperReview.DataGrid.MovePrevious
| Move Next = GrooperReview.DataGrid.MoveNext
| Execute Lookup = GrooperReview.DataGrid.ExecuteLookup
| Run Rule = GrooperReview.DataGrid.RunRule
| Validate All = GrooperReview.DataGrid.ValidateAll
| Rubberband = GrooperReview.DataGrid.Rubberband
| Copy JSON = GrooperReview.DataGrid.CopyJSON
| Copy Field JSON = GrooperReview.DataGrid.CopyFieldJSON
| Rubberband Zone = GrooperReview.DataGrid.RubberbandZone
| Rubberband OCR = GrooperReview.DataGrid.RubberbandOCR
| Confirm = GrooperReview.DataGrid.Confirm
| Confirm All = GrooperReview.DataGrid.ConfirmAll
| Save Value = GrooperReview.DataGrid.SaveValue
| RenderModes = GrooperReview.DataGrid.RenderModes
| Append Row = GrooperReview.DataGrid.AppendRow
| Clear All Rows = GrooperReview.DataGrid.ClearAllRows
| Rubberband Rows = GrooperReview.DataGrid.RubberbandRows
| Insert Row = GrooperReview.DataGrid.InsertRow
| Delete Row = GrooperReview.DataGrid.DeleteRow
| Split Row = GrooperReview.DataGrid.SplitRow
| Duplicate Row = GrooperReview.DataGrid.DuplicateRow
| Move Row Up = GrooperReview.DataGrid.MoveRowUp
| Move Row Down = GrooperReview.DataGrid.MoveRowDown
| Capture Rows = GrooperReview.Views.DataGrid.Commands.CaptureRows
| Read Empty Cells = GrooperReview.Views.DataGrid.Commands.ReadEmptyCells
| Run Fill Method = GrooperReview.Views.DataGrid.Commands.RunFillMethod
| Clear Results = GrooperReview.BatchView.SeparationList+ClearResults
| Revert = GrooperReview.BatchView.SeparationList+Revert
| Append = GrooperReview.BatchView.SeparationList+Append
| Prepend = GrooperReview.BatchView.SeparationList+Prepend
| Separate = GrooperReview.BatchView.SeparationList+Separate
| Unseparate = GrooperReview.BatchView.SeparationList+Unseparate
| Select All = GrooperReview.BatchView.SeparationList+SelectAll
| Select Span = GrooperReview.BatchView.SeparationList+SelectSpan
| Select Type = GrooperReview.BatchView.SeparationList+SelectType
| Train Pages = GrooperReview.BatchView.SeparationList+Train
| Next Loose Page = GrooperReview.BatchView.SeparationList+NextLoosePage
| Copy = GrooperReview.BatchView.SeparationList+Copy
| Paste = GrooperReview.BatchView.SeparationList+Paste
| Go to Next Issue = GrooperReview.BatchView.ClassifyViewer+GoToNextIssue
| Confirm Page = GrooperReview.BatchView.ThumbnailViewer+ConfirmPage
| Goto Next Unconfirmed = GrooperReview.BatchView.ThumbnailViewer+GotoNextUnconfirmed
| View Properties = GrooperReview.BatchView.ThumbnailViewer+ViewProperties
| SortType = GrooperReview.BatchView.ThumbnailViewer+SortType
| Confirm Page = GrooperReview.BatchView.BatchViewer+ConfirmPage
| Scan = GrooperReview.BatchView.ScanViewer+Scan
| Scan Before = GrooperReview.BatchView.ScanViewer+ScanBefore
| Scan After = GrooperReview.BatchView.ScanViewer+ScanAfter
| Scan Repeat = GrooperReview.BatchView.ScanViewer+ScanRepeat
| Cut = GrooperReview.Objects.NodeCommands+Cut
| Copy = GrooperReview.Objects.NodeCommands+Copy
| Paste = GrooperReview.Objects.NodeCommands+Paste
| Process Converter = GrooperReview.Objects.CreateBatch+ProcessConverter
| Query Editor = GrooperReview.Pages.Stats.StatsKioskSettings+QueryEditor
| Activity Editor = GrooperReview.Pages.Jobs.JobFilter+ActivityEditor
| Process Editor = GrooperReview.Pages.Jobs.JobFilter+ProcessEditor
| Step Editor = GrooperReview.Pages.Jobs.JobFilter+StepEditor
| Assistant Converter = GrooperReview.Pages.Search.AssistantChat+AssistantConverter
| Name Converter = GrooperReview.Pages.Search.DownloadCustom+NameConverter
| TaskScope = GrooperReview.Pages.Search.SubmitJob+TaskScope
| Activity Converter = GrooperReview.Pages.Search.SubmitJob+ActivityConverter
| Scope Converter = GrooperReview.Pages.Search.SubmitJob+ScopeConverter
| Review Document = GrooperReview.Pages.Search.SearchPage+ReviewDoc
| Go to Document = GrooperReview.Pages.Search.SearchPage+GoToDoc
| View Properties = GrooperReview.Pages.Search.SearchPage+ViewProperties
| Copy Link = GrooperReview.Pages.Search.SearchPage+CopyDocLink
| View Properties = GrooperReview.Pages.Design.ContentType_Documents+ViewProperties
| CellStyle = GrooperReview.Pages.Design.FrxGrid+CellStyle
| View Properties = GrooperReview.Pages.Chat.ChatPage+ViewProperties
| Review Only = GrooperReview.Pages.Batches.BatchHistoryViewer+ReviewOnly
| View Properties = GrooperReview.Pages.Batches.BatchList+ViewProperties
| Review = GrooperReview.Pages.Batches.BatchList+Review
| Open = GrooperReview.Pages.Batches.BatchList+Open
| Rule Converter = GrooperReview.DataGrid.RunRule+RuleConverter
| Scope Converter = GrooperReview.DataGrid.ConfirmAll+ScopeConverter
| RubberbandCommand(Of Element Type) = GrooperReview.DataGrid.DataGrid+RubberbandCommand`1
| Fill Method Converter = GrooperReview.Views.DataGrid.Commands.RunFillMethod+FillMethodConverter
| CardOptions = GrooperReview.Controls.CardList+CardOptions
| Create Group = GrooperReview.Controls.CodeEditor+CreateGroup
| Start Required Mode = GrooperReview.Controls.CodeEditor+StartRequiredMode
| End Required Mode = GrooperReview.Controls.CodeEditor+EndRequiredMode
| Cut = GrooperReview.Controls.CodeEditor+Cut
| Copy = GrooperReview.Controls.CodeEditor+Copy
| Paste = GrooperReview.Controls.CodeEditor+Paste
| Undo = GrooperReview.Controls.CodeEditor+Undo
| Redo = GrooperReview.Controls.CodeEditor+Redo
| ListOptions = GrooperReview.Controls.ObjectList+ListOptions
| SelectModes = GrooperReview.Controls.TreeViewer+SelectModes
| Parts = GrooperReview.Controls.TreeViewer+Parts
| View Properties = GrooperReview.Controls.TreeViewer+ViewProperties
| Go to Flagged = GrooperReview.Controls.TreeViewer+GotoFlagged
| Validate Branch = GrooperReview.Controls.TreeViewer+ValidateBranch
| PropertyFlags = GrooperReview.Controls.PropertyGrid.PropertyGrid+PropertyFlags
| InputKind = GrooperReview.Controls.PropertyGrid.PropertyGrid+InputKind
| ModelCommand(Of Item Type, Model Type) = GrooperReview.Controls.PropertyGrid.PropertyGrid+ModelCommand`2
| Property Grid Command = GrooperReview.Controls.PropertyGrid.PropertyGrid+PropertyGridCommand
| Clear = GrooperReview.Controls.PropertyGrid.PropertyGrid+Clear
| Reset = GrooperReview.Controls.PropertyGrid.PropertyGrid+Reset
| Reset All = GrooperReview.Controls.PropertyGrid.PropertyGrid+ResetAll
| Copy Properties = GrooperReview.Controls.PropertyGrid.PropertyGrid+CopyProperties
| Paste Properties = GrooperReview.Controls.PropertyGrid.PropertyGrid+PasteProperties
| ChangeKind = GrooperReview.Utils.ChangeTracker+ChangeKind
<!--- Commands with type names --->
| AI Chat - Delete = Grooper.GPT.AIChat+DeleteChat
| AI Chat - Rename = Grooper.GPT.AIChat+Rename
 
| Attachment Type - Rename Attachment = Grooper.Core.MimeTypeHandler+RenameAttachment
| Attachment Type - Change Extension = Grooper.Core.MimeTypeHandler+ChangeExtension
| Attachment Type - Remove Attachment = Grooper.Core.MimeTypeHandler+RemoveAttachment
| Attachment Type - Remove PDF Version = Grooper.Core.MimeTypeHandler+RemovePdfVersion
 
| Batch - Archive = Grooper.Core.Batch+Archive
| Batch - Change Priority = Grooper.Core.Batch+ChangePriority
| Batch - Combine = Grooper.Core.Batch+Combine
| Batch - Pause = Grooper.Core.Batch+Pause
| Batch - Reset = Grooper.Core.Batch+Reset
| Batch - Remove Job History = Grooper.Core.Batch+RemoveJobHistory
| Batch - Resume = Grooper.Core.Batch+Resume
| Batch - Send To Production = Grooper.Core.Batch+SendToProduction
| Batch - Send To Test = Grooper.Core.Batch+SendToTest
| Batch - Update Process = Grooper.Core.Batch+UpdateProcess
 
| Batch Folder - Add To Index = Grooper.GPT.AddToIndex
| Batch Folder - Assign Document Type = Grooper.Core.BatchFolder+AssignDocumentType
| Batch Folder - Classify Command = Grooper.Core.BatchFolder+ClassifyCommand
| Batch Folder - Classify = Grooper.Core.BatchFolder+Classify
| Batch Folder - Train As = Grooper.Core.BatchFolder+TrainAs
| Batch Folder - Train From = Grooper.Core.BatchFolder+TrainFrom
| Batch Folder - Collapse = Grooper.Core.BatchFolder+Collapse
| Batch Folder - Edit Type Assignment = Grooper.Core.BatchFolder+EditTypeAssignment
| Batch Folder - Extract = Grooper.Core.BatchFolder+Extract
| Batch Folder - Group Children = Grooper.EDI.GroupChildren
| Batch Folder - Insert Control Sheets = Grooper.Capture.InsertControlSheets
| Batch Folder - New Text Document = Grooper.Core.BatchFolder+NewTextDocument
| Batch Folder - Remove From Index = Grooper.GPT.RemoveFromIndex
| Batch Folder - Remove Level = Grooper.Core.BatchFolder+RemoveLevel
| Batch Folder - Revert To Loose Pages = Grooper.Core.BatchFolder+RevertToLoosePages
| Batch Folder - Set Field Value = Grooper.Core.BatchFolder+SetFieldValue
| Batch Folder - Sort Children = Grooper.Core.BatchFolder+SortChildren
 
| Batch Object - Append = GrooperReview.BatchView.SeparationList+Append
| Batch Object - Append To Previous = Grooper.Core.BatchObject+AppendToPrevious
| Batch Object - Clear Flag = Grooper.Core.BatchObject+ClearFlagCommand
| Batch Object - Create New Folder = Grooper.Core.BatchObject+CreateNewFolder
| Batch Object - Add Folder = Grooper.Core.BatchObject+AddFolder
| Batch Object - Insert Folder = Grooper.Core.BatchFolder+InsertFolder
| Batch Object - Flag Item = Grooper.Core.BatchObject+FlagCommand
| Batch Object - Merge Selected = Grooper.Core.BatchObject+MergeSelected
| Batch Object - Prepend to Next = Grooper.Core.BatchObject+PrependToNext
| Batch Object - Rename = Grooper.Core.BatchObject+Rename
| Batch Object - Run Step = Grooper.Core.BatchObject+RunStep
| Batch Object - Run Activity = Grooper.Core.BatchObject+RunActivity
| Batch Object - Send To Test Batch = Grooper.Core.BatchObject+SendToTestBatch
| Batch Object - Copy To Test Batch = Grooper.Core.BatchObject+CopyToTestBatch
| Batch Object - Move To Test Batch = Grooper.Core.BatchObject+MoveToTestBatch
| Batch Object - Separate = GrooperReview.BatchView.SeparationList+Separate
| Batch Object - Split Folder = Grooper.Core.BatchObject+SplitFolder
| Batch Object - Unseparate = GrooperReview.BatchView.SeparationList+Unseparate
 
| Batch Page - Clear Results = GrooperReview.BatchView.SeparationList+ClearResults
| Batch Page - Generate Thumbnail = Grooper.Core.BatchPage+GenerateThumbnail
| Batch Page - Image Command = Grooper.Core.BatchPage+ImageCommand
| Batch Page - Display As Color = Grooper.Core.BatchPage+DisplayAsColor
| Batch Page - Display As Grayscale = Grooper.Core.BatchPage+DisplayAsGrayscale
| Batch Page - Display As Binary = Grooper.Core.BatchPage+DisplayAsBinary
| Batch Page - Image Editing Command = Grooper.Core.BatchPage+ImageEditingCommand
| Batch Page - Invert = Grooper.Core.BatchPage+Invert
| Batch Page - Reset = Grooper.Core.BatchPage+Reset
| Batch Page - Rotate Left = Grooper.Core.BatchPage+RotateLeft
| Batch Page - Rotate Right = Grooper.Core.BatchPage+RotateRight
| Batch Page - Undo Image Cleanup = Grooper.Core.BatchPage+UndoImageCleanup
| Batch Page - Image Review Command = Grooper.Core.BatchPage+ImageReviewCommand
| Batch Page - Apply Image Cleanup = Grooper.Core.BatchPage+ApplyCleanup
| Batch Page - Prepend = GrooperReview.BatchView.SeparationList+Prepend
| Batch Page - Rasterize = Grooper.Core.BatchPage+Rasterize
| Batch Page - Revert = GrooperReview.BatchView.SeparationList+Revert
 
| Batch Process - Add Activity = Grooper.Core.BatchProcess+AddActivity
| Batch Process - Publish = Grooper.Core.BatchProcess+Publish
| Batch Process - Unpublish = Grooper.Core.BatchProcess+Unpublish
| Batch Process - Create Project = Grooper.Core.BatchProcess+CreateProject
 
| CMIS Connection - Reset = Grooper.CMIS.CmisConnection+Reset
| CMIS Connection - Import Repository = Grooper.CMIS.CmisConnection+ImportRepository
 
| CMIS Document Link - Delete CMIS Document = Grooper.CMIS.CmisLink+DeleteCommand
| CMIS Document Link - Load = Grooper.CMIS.CmisLink+Load
| CMIS Document Link - Move CMIS Document = Grooper.CMIS.CmisLink+Move
| CMIS Document Link - Save Version = Grooper.CMIS.CmisLink+SaveVersionCommand
| CMIS Document Link - Update = Grooper.CMIS.CmisLink+Update
 
| CMIS Export Map - Auto Map = Grooper.CMIS.CMISExportMap+AutoMap
 
| CMIS Folder Link - Delete = Grooper.CMIS.CmisFolderLink+DeleteCommand
| CMIS Folder Link - Load Children = Grooper.CMIS.CmisFolderLink+LoadChildrenCommand
| CMIS Folder Link - Load Pages = Grooper.CMIS.CmisFolderLink+LoadPages
| CMIS Folder Link - Load Properties = Grooper.CMIS.CmisFolderLink+LoadPropertiesCommand
| CMIS Folder Link - Save Properties = Grooper.CMIS.CmisFolderLink+SavePropertiesCommand
 
| CMIS Import Map - Auto Map = Grooper.CMIS.CMISImportMap+AutoMap
| CMIS Repository - Reset = Grooper.CMIS.CmisRepository+Reset
| CMIS Type Definition - Generate Local Type = Grooper.CMIS.GenerateLocalType
| Column Map - Auto Map = Grooper.Activities.ColumnMap+AutoMap
| Content Link - Remove Link = Grooper.Core.ContentLink+RemoveLink
 
 
| Content Type - Clean Overrides = Grooper.Core.ContentType+CleanOverrides
| Content Type - Create Data Model = Grooper.Core.ContentType+CreateDataModel
| Content Type - Create Local Resources Folder = Grooper.Core.ContentType+CreateLocalResourcesFolder
| Content Type - Create Search Index = Grooper.GPT.CreateSearchIndex
| Content Type - Delete Search Index = Grooper.GPT.DeleteSearchIndex
| Content Type - Generate Control Sheets = Grooper.Capture.GenerateControlSheets
| Content Type - Purge Training = Grooper.Core.ContentType+PurgeTraining
| Content Type - Rebuild Training = Grooper.Core.ContentType+RebuildTraining
| Content Type - Submit Indexing Job = Grooper.GPT.SubmitIndexingJob
 
| Copy Base - Auto Map = Grooper.Core.CopyBase+AutoMap
 
| Data Connection - Connection Command = Grooper.Core.DataConnection+ConnectionCommand
| Data Connection - Create Table = Grooper.Core.DataConnection+CreateTable
| Data Connection - Create Database = Grooper.Core.DataConnection+CreateDatabase
| Data Connection - Drop Table = Grooper.Core.DataConnection+DropTable
| Data Connection - Test Connection = Grooper.Core.DataConnection+TestConnection
 
| Data Element - Remove Overrides = Grooper.Core.DataElement+RemoveOverrides
| Data Element Instance - Execute Lookup = GrooperReview.DataGrid.ExecuteLookup
 
| Data Field Container - Build Fine Tuning File = Grooper.GPT.BuildFineTuningFile
| Data Field Container - Import Schema = Grooper.Core.DataFieldContainer+ImportSchema
| Data Field Container - Generate Schema = Grooper.Core.DataFieldContainer+GenerateSchema
 
| Data Type - Convert To Value Reader = Grooper.Extract.DataType+ConvertToValueReader
| Document Instance - Validate All = GrooperReview.DataGrid.ValidateAll
 
| EDI File - Bundle = Grooper.EDI.EDIFile+Bundle
| EDI File - Split Envelopes = Grooper.EDI.EDIFile+SplitEnvelopes
| EDI File - Load Data = Grooper.EDI.EDIFile+LoadData
 
| Excel Document - Convert to CSV = Grooper.Office.ExcelToCsv
| Exchange - Rebuild Search Folder = Grooper.Messaging.ExchangeBinding+RebuildSearchFolder
| Field Class - Purge Training = Grooper.Extract.FieldClass+PurgeTraining
 
| Field Container Instance - Run Fill Method = GrooperReview.Views.DataGrid.Commands.RunFillMethod
| Field Container Instance - Run Rule = GrooperReview.DataGrid.RunRule
 
| Field Instance - Confirm = GrooperReview.DataGrid.Confirm
| Field Instance - Confirm All = GrooperReview.DataGrid.ConfirmAll
| Field Instance - Rubberband Header Label = GrooperReview.DataGrid.RubberbandHeaderLabel
| Field Instance - Rubberband OCR = GrooperReview.DataGrid.RubberbandOCR
| Field Instance - Rubberband Zone = GrooperReview.DataGrid.RubberbandZone
 
| File Store - Test Connection = Grooper.FileStore+TestConnection
| File Store - Move Objects Here = Grooper.FileStore+MoveObjectsHere
 
| File System Link - Change File Attributes = Grooper.Core.FileSystemLink+ChangeAttributes
| File System Link - Copy File = Grooper.Core.FileSystemLink+CopyFile
| File System Link - Delete File = Grooper.Core.FileSystemLink+DeleteFile
| File System Link - Load Content = Grooper.Core.FileSystemLink+LoadContent
| File System Link - Move File = Grooper.Core.FileSystemLink+MoveFile
| File System Link - Save Content = Grooper.Core.FileSystemLink+SaveContent
 
| Folder - Remove Empty Subfolders = Grooper.Project+RemoveEmptySubfolders
 
| FTP Link - Delete File = Grooper.Messaging.FtpLink+DeleteFile
| FTP Link - Load Content = Grooper.Messaging.FtpLink+LoadContent
| FTP Link - Save Content = Grooper.Messaging.FtpLink+SaveContent
 
| Property Grid - Clear = GrooperReview.Controls.PropertyGrid.PropertyGrid+Clear
| Property Grid - Copy Properties = GrooperReview.Controls.PropertyGrid.PropertyGrid+CopyProperties
| Property Grid - Paste Properties = GrooperReview.Controls.PropertyGrid.PropertyGrid+PasteProperties
| Property Grid - Reset = GrooperReview.Controls.PropertyGrid.PropertyGrid+Reset
| Property Grid - Reset All = GrooperReview.Controls.PropertyGrid.PropertyGrid+ResetAll
 
| HTML Document - Convert to PDF = Grooper.Messaging.HTMLDocument+ConvertToPDF
| HTML Document - Condition HTML = Grooper.Messaging.HTMLDocument+ConditionHTML
| HTML Document - Convert To Text = Grooper.Messaging.HTMLDocument+ConvertToText
 
| HTTP Link - Load Content = Grooper.Messaging.HTTPLink+LoadContent
| HTTP Link - Rename Attachment = Grooper.Messaging.HTTPLink+RenameAttachment
 
| JSON File - Load Data = Grooper.EDI.JsonFile+LoadData
| JSON File - Split = Grooper.EDI.JsonFile+Split
 
| Lexicon - Intersect = Grooper.Core.Lexicon+Intersect
| Lexicon - Merge Training = Grooper.Core.Lexicon+MergeTraining
| Lexicon - Normalize = Grooper.Core.Lexicon+Normalize
| Lexicon - Subtract = Grooper.Core.Lexicon+Subtract
| Lexicon - Truncate = Grooper.Core.Lexicon+Truncate
 
| Machine - Tune File System = Grooper.Machine+TuneFileSystem
 
| Mail Link - Expand Attachments = Grooper.Messaging.MailLink+ExpandAttachments
| Mail Link - Delete Message = Grooper.Messaging.MailLink+DeleteMessage
| Mail Link - Load Content = Grooper.Messaging.MailLink+LoadContent
 
| Mail Message - Convert To RFC822 = Grooper.Messaging.MailMimeTypeHandler+ConvertToRFC822
| Mail Message - Expand Attachments = Grooper.Messaging.MailMimeTypeHandler+ExpandAttachments
 
| Node - Add Multiple Items = Grooper.GrooperNode+AddMultipleItems
| Node - Clear Children = Grooper.GrooperNode+ClearChildren
| Node - Clone = Grooper.GrooperNode+CloneItem
| Node - Cut = GrooperReview.Objects.NodeCommands+Cut
| Node - Copy = GrooperReview.Objects.NodeCommands+Copy
| Node - Delete = Grooper.GrooperNode+DeleteItem
| Node - Move Down = Grooper.GrooperNode+MoveDown
| Node - Move Up = Grooper.GrooperNode+MoveUp
| Node - Paste = GrooperReview.Objects.NodeCommands+Paste
| Node - Publish To Repository = Grooper.Core.PublishToRepository
| Node - Rename = Grooper.GrooperNode+Rename
 
| OAuth Client Credentials - Test = Grooper.GPT.OAuthClientCredentials+Test
 
| Object Library - Create Backup = Grooper.ObjectLibrary+CreateBackup
| Object Library - Rename Script = Grooper.ObjectLibrary+RenameScript
 
| PDF Document - Repair = Grooper.Core.PdfMimeTypeHandler+Repair
| PDF Document - Compact = Grooper.Core.PdfMimeTypeHandler+Compact
| PDF Document - Burst = Grooper.Core.PdfMimeTypeHandler+Burst
 
| Project - Remove Empty Subfolders = Grooper.Project+RemoveEmptySubfolders
 
| PST File - Burst = Grooper.Office.PSTHandler+Burst
| PST Link - Load Content = Grooper.Office.PstLink+LoadContent
 
| Resource File - Rename = Grooper.ResourceFile+Rename
| Resource File - Start Fine Tuning Job = Grooper.GPT.StartFineTuningJob
| Resource File - Delete Fine Tuned Model = Grooper.GPT.DeleteFineTunedModel
 
| Root - Run Import = Grooper.Core.RunImport
| Root - System Maintenance = Grooper.GrooperRoot+SystemMaintenance
| Root - Database Cleanup = Grooper.GrooperRoot+DatabaseCleanup
| Root - Rebuild Indexes = Grooper.GrooperRoot+RebuildIndexes
 
| Saved Query - Delete = Grooper.GPT.SavedQuery+DeleteQuery
| Saved Query - Rename = Grooper.GPT.SavedQuery+Rename
 
| Search Index - Generate Subsets = Grooper.GPT.SearchIndexReference+GenerateSubsets
 
| Section Instance - Record Command = GrooperReview.DataGrid.RecordCommand
| Section Instance - Delete Record = GrooperReview.DataGrid.DeleteRecord
| Section Instance - Insert Record = GrooperReview.DataGrid.InsertRecord
| Section Instance - Merge With Previous = GrooperReview.DataGrid.MergeWithPrevious
| Section Instance - Move Next = GrooperReview.DataGrid.MoveNext
| Section Instance - Move Previous = GrooperReview.DataGrid.MovePrevious
| Section Instance - Rubberband = GrooperReview.DataGrid.Rubberband
 
| Section Instance Collection - Append Record = GrooperReview.DataGrid.AppendRecord
 
| SFTP Link - Load Content = Grooper.Messaging.SftpLink+LoadContent
| SFTP Link - Save Content = Grooper.Messaging.SftpLink+SaveContent
| SFTP Link - Delete File = Grooper.Messaging.SftpLink+DeleteFile
 
| Table Instance - Append Row = GrooperReview.DataGrid.AppendRow
| Table Instance - Capture Rows = GrooperReview.Views.DataGrid.Commands.CaptureRows
| Table Instance - Clear All Rows = GrooperReview.DataGrid.ClearAllRows
| Table Instance - Read Empty Cells = GrooperReview.Views.DataGrid.Commands.ReadEmptyCells
| Table Instance - Rubberband Header = GrooperReview.DataGrid.RubberbandHeader
| Table Instance - Rubberband Rows = GrooperReview.DataGrid.RubberbandRows
 
| Table Row Instance - Delete Row = GrooperReview.DataGrid.DeleteRow
| Table Row Instance - Duplicate Row = GrooperReview.DataGrid.DuplicateRow
| Table Row Instance - Insert Row = GrooperReview.DataGrid.InsertRow
| Table Row Instance - Move Row Down = GrooperReview.DataGrid.MoveRowDown
| Table Row Instance - Move Row Up = GrooperReview.DataGrid.MoveRowUp
| Table Row Instance - Split Row = GrooperReview.DataGrid.SplitRow
 
| Text Document - Insert Page Breaks = Grooper.Extract.TextDocument+InsertPageBreaks
| Text Document - Normalize = Grooper.Extract.TextDocument+Normalize
| Text Document - Split = Grooper.Extract.TextDocument+Split
 
| Value Reader - Convert To Data Type = Grooper.Extract.ValueReader+ConvertToDataType
| vCard - Expand Photo = Grooper.Messaging.VCardTypeHandler+ExpandPhoto
| Word Document - Convert to PDF = Grooper.Office.WordDocument+WordToPdf
 
| XML File - Condition XML = Grooper.EDI.XmlFile+ConditionXML
| XML File - Format = Grooper.EDI.XmlFile+Format
| XML File - Load Data = Grooper.EDI.XmlFile+LoadData
| XML File - Split = Grooper.EDI.XmlFile+Split
| XML File - Validate Schema = Grooper.EDI.XmlFile+ValidateSchema
 
| ZIP Archive - Update = Grooper.Core.ZipHandler+Update
| ZIP Archive - Unzip = Grooper.Core.ZipHandler+Unzip
| ZIP Archive - Unpackage = Grooper.Core.ZipHandler+Unpackage
 
| ZIP Link - Load Content = Grooper.Core.ZipLink+LoadContent
<!--- Not compiled by Scott --->
| UI Element = GrooperReview.Models.UIElement
| Semantic Quoting Query = Grooper.GPT.Semantic+SemanticQuotingQuery
| #default = Error - Report error to groopereducation@bisok.com
}}<!---Scott helped generate this list from code. If we need to have him regenerate it, he may need this code:
 
System.IO.File.WriteAllLines("C:\\temp\\types.txt", _types.Select(kvp => $"| {kvp.Value.GetDisplayName()} = {kvp.Value.FullName}"));
--->

Latest revision as of 14:01, 10 September 2025

Error - Report error to groopereducation@bisok.com

Retrieved from "https://wiki.grooper.com/index.php?title=Template:TypeName&oldid=31030"