Update Classification

Updates objects that support document classification.

The Policy Management APIs provided an abstracted layer on top of entity extraction, categorization and related functionality to allow the definition of policies for the management of information. Classifications can be created to group documents and other objects into collections. Policies enact actions upon documents associated with a collection such as indexing.

Classification involves sorting documents into Collections; all documents in a collection share some common criteria, identified using Conditions.

The collection or collections that a document matches can influence how it is indexed and determine policies that are executed against it.

A Collection Sequence is an ordered list of collections that documents are assessed against; each collection is considered in order until the document matches a collection with a stop on match instruction. Documents can match multiple collections in a collection sequence.

The Update Classification API allows collection sequences, collections, conditions, field sources, lexicons, and lexicon expressions to be updated.

Quick Start

Using this API you can update existing classification objects.

/1/api/[async|sync]/createclassificationobjects/v1?type=collection_sequence&name=new_sequence_name&description=Updated%20descriptive%20text

The type of classification object you are updating determines the additional information that can be provided in the additional parameter.

The following classification object types can be updated:

  • collection. A set of documents that share some common criteria.
  • collection sequence. An ordered set of Collections.
  • condition. Each Collection is identified using one or more Conditions.
  • field source. Information on how to retrieve a property value from a document for Condition assessment.
  • lexicon. A list of terms, phrases, or expressions that can be used when defining Conditions.
  • lexicon expression. An entry in a Lexicon.

The name and description can be any values that help you identify the classification object. name is mandatory for collections, collection sequences, conditions, and lexicons, and ignored for lexicon expressions and field sources. description is optional for collections, collection sequences, conditions and lexicons and ignored for lexicon expressions and field sources.

The additional parameter takes a JSON object specifying additional parameters that can be provided for the classification object type.

Collection

An example of the required format for additional JSON for a collection object is:

{
    "policy_ids" : [1, 2],
    "condition" :
    {
        "type" : "condition",
        "additional": {
            "type" : "string"
            "field" : "DRECONTENT",
            "value" : "cat DNEAR4 dog",
            "operator" : "contains"
        }
    }
}

The policy_ids field, if present, identifies one or more policies that should be assigned to the collection. For more information about policies, see Create Policy. You cannot have multiple policies of the same type on a collection.

The condition field, if present, identifies one or more conditions that are used to determine if documents are in the collection.

You can use undefined or null for policy_ids or condition fields to leave any existing entry unchanged; to remove all existing entries use an empty array.

Collection Sequence

An example of the required format for additional JSON for a collection sequence object is:

{
    "collection_sequence_entries" :
        [{
            "order" : 10,
            "collection_ids" : [7],
            "stop_on_match" : "true"
        },
        {
            "order" : 20,
            "collection_ids" : [10,11],
            "stop_on_match" : "false"
        }],
    "default_collection_id" : 5
}

The collection_sequence_entries array defines one or more entries to add to the collection sequence. Each entry contains one or more collections and has an order and a stop_on_match attribute.

The order field identifies where the collection entry appears in the collection sequence. Any numeric value can be specified and entries are ordered by their values, from lowest to highest.

The collection_ids field identifies the collections that are being added to the collection sequence. There will typically be one collection per collection entry.

If a collection sequence entry has a stop_on_match parameter set to true then classification against further collections in the collection sequence will stop if a document matches one of the collections in the collection entry. The default is false.

The default_collection_id field defines a default collection that is assigned to documents that fail to match any collection in the sequence.

The full_condition_evaluation parameter can be set to true to cause all conditions within a Boolean OR condition to be evaluated instead of stopping after the first matching condition. The default is false.

Condition

The type field identifies the type of the condition being added. Valid values are Boolean, Date, Exists, Fragment, Lexicon, Not, Number, Regex, String, and Text.

Boolean Conditions

An example of the format for additional JSON for a condition object of type Boolean is:

{
    "type" : "boolean",
    "operator" : "or",
    "notes" : "Author is John Smith or Sarah Smith",
    "children": [{
        "type": "condition",
        "additional": {
            "type" : "string",
            "field" : "AUTHOR",
            "operator" : "is",
            "value" : "John Smith"
        }
    },{
        "type": "condition",
        "additional": {
            "type" : "string",
            "field" : "AUTHOR",
            "operator" : "is",
            "value" : "Sarah Smith"
        }
    }]
}

This condition will match a document that has an AUTHOR field of John Smith or Sarah Smith.

Boolean condition types require an operator parameter.

The operator parameter indicates the type of Boolean join that is being performed on child conditions. Valid operators for Boolean conditions are and and or.

The notes parameter allows you to store some additional infomation about a condition.

Date Property Conditions

An example of the format for additional JSON for a condition object of type Date is:

{
    "type" : "date",
    "field" : "AU_IMPORT_CREATEDDATE_EPOCHSECONDS",
    "operator" : "before",
    "value" : "2014-10-10T10.13:19Z"
}

Date condition types require field, operator, and value parameters.

The field parameter indicates the name of the date property being tested.

The operator parameter indicates the type of test that is being performed on the date property. Valid operators for Date conditions are before, after, and on.

The value parameter indicates the value that the date property is being tested against.

The value can have the following formats:

  • A date in epoch foramt, postfixed with e: 1412935999e corresponds to 2014-10-10T10.13:19Z
  • A date in ISO-8601 format: 2014-10-10T10.13:19Z
  • A date period in ISO-8601 period format: P3Y6M4DT12H30M5S corresponds to 3 years, 6 months, 4 days, 12 hours, 30 minutes, and 5 seconds
  • A day of the week – The following values may be truncated to Mon etc.: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
  • A time of day in hh:mm or hh:mm:ss format: 12:00 or 14:30
Exists Conditions

An example of the format for additional JSON for a condition object of type Exists is:

{
    "type" : "exists",
    "field" : "VITAL_FLAG"
}

Exists condition types require a field parameter.

The field parameter indicates the name of the property being tested.

Fragment Conditions

An example of the format for additional JSON for a condition object of type Fragment is (where 132 is the ID of an existing condition that was created with is_fragment set to true):

{
    "type" : "fragment",
    "value" : "132"
}

Fragment condition types require a value parameter.

The value parameter indicates the condition fragment to be included.

An example of the format for additional JSON for a condition object of type Lexicon is (where 12 is the ID of an existing lexicon):

{
    "type" : "lexicon",
    "field" : "TITLE",
    "value" : "12"
}

Lexicon condition types require field and value parameters.

The field parameter indicates the name of the string property being tested.

The value parameter indicates the lexicon that the string property is being tested against.

Not Conditions

An example of the format for additional JSON for a condition object of type Not is:

{
    "type" : "not",
    "condition": {
        "type": "condition",
        "additional": {
            "type" : "string",
            "field" : "AUTHOR",
            "operator" : "is",
            "value" : "John Smith"
        }
    }
}

This condition will match documents which have an AUTHOR field that is NOT John Smith.

Number Property Conditions

An example of the format for additional JSON for a condition object of type Number is:

{
    "type" : "number",
    "field" : "SIZE",
    "operator" : "gt",
    "value" : 1000
}

Number condition types require field, operator, and value parameters.

The field parameter indicates the name of the numeric property being tested.

The operator parameter indicates the type of test that is being performed on the numeric property. Valid operators for Number conditions are gt, lt, and eq.

The value parameter indicates the value that the numeric property is being tested against.

Regex Property Conditions

An example of the format for additional JSON for a condition object of type Regex is:

{
    "type" : "regex",
    "field" : "DRECONTENT",
    "value" : "\\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}\\b"
}

Regex condition types require field and value parameters.

The field parameter indicates the name of the property being tested.

The value parameter indicates the regular expression that the property is being tested against.

String Property Conditions

An example of the format for additional JSON for a condition object of type String is:

{
    "type" : "string",
    "field" : "AUTHOR",
    "operator" : "is",
    "value" : "John Smith"
}

String condition types require field, operator, and value parameters.

The field parameter indicates the name of the string property being tested.

The operator parameter indicates the type of test that is being performed on the string property. Valid operators for String conditions are is, starts_with, and ends_with.

The value parameter indicates the value that the string property is being tested against.

Text Property Conditions

An example of the format for additional JSON for a condition object of type Text is:

{
    "type" : "text",
    "field" : "DRECONTENT",
    "value" : "cat DNEAR4 dog"
}

Text condition types require field and value parameters.

The field parameter indicates the name of the string property being tested. This will normally be DRECONTENT.

The value parameter indicates the value that the string property is being tested against.

Field Source

An example of the required format for additional JSON for a field source object is:

{
    "field_type" : "string",
    "source_arguments" : { 
        "fields": ["AU_REPOSITORY_TO_RFC822","To","To"]
    }
}
{
    "field_type" : "string",
    "source_arguments" : {
        "eduction_onpremise": [
                {
                    "entity_type": "number_banking_ca.ecr", 
                    "entity_name": ["number/bankaccount/ca","number/cpa_transit/ca"],
                    "field_source":"DRECONTENT"
                }
            ],
        "eduction": [
                {
                    "entity_type":["bankaccount_ca"],
                    "entity_name": [],
                    "field_source":"CONTENT"
                }
            ]
        }
}

The field_type indicates the type of the field source. This can be string, number or date.

The source_arguments contains the information required to use the field source.

fields contain one or more Haven OnDemand field names that provide the property value to be used. If multiple field names are provided they are checked in order and the first value found is used.

eduction and eduction_on_premise properties contain the information about the files used for eduction.

Lexicon

An example of the required format for additional JSON for a lexicon object is:

{
"lexicon_expressions" :
    [{
        "type" : "text",
        "expression" : "antelope"
    },{
        "type" : "text",
        "expression" : "african DNEAR elephants"
    }]
}

The lexicon_expressions array defines one or more lexicon expressions to add to the lexicon. Each lexicon expression has a type and an expression. You can use undefined or null to leave any existing entry unchanged; to remove all existing entries use an empty array.

The type field indicates the type of the lexicon expression, one of text or regex.

The expression field contains the expression to add to the lexicon. It can be a term, phrase, or Haven OnDemand proximity expression for text type, or a regular expression for regex type.

Lexicon Expression

An example of the required format for additional JSON for a lexicon expression object is:

{
    "lexicon_id" : 2,
    "type" : "text",
    "expression" : "lion"
}

The lexicon_id identifies the lexicon that the lexicon expression is to be added to. You can use undefined or null to leave any existing entry unchanged; to remove all existing entries use an empty array.

The type field indicates the type of the lexicon expression, one of text or regex.

The expression field contains the expression to add to the lexicon. It can be a term, phrase or Haven OnDemand proximity expression for text type or a regular expression for regex type.

Synchronous
https://api.havenondemand.com/1/api/sync/updateclassificationobjects/v1
Asynchronous
https://api.havenondemand.com/1/api/async/updateclassificationobjects/v1
Authentication

This API requires an authentication token to be supplied in the following parameter:

Parameter Description
apikey The API key to use to authenticate the API request.
Parameters

This API accepts the following parameters:

Required
Name Type Description
type
enum The type of classification object.
id
number The ID of the classification object to be updated.
Optional
Name Type Description
additional
json Specify a JSON object of additional parameters relevant for the type of classification object being updated.
description
string A new textual description for the classification object, leave empty to remove the existing description. Does not apply to lexicon_expression or condition types.
name
string The new name of the classification object. Does not apply to the lexicon_expression type.
Enumeration Types

This API's parameters use the enumerations described below:

type
The type of classification object.
collection_sequence Collection Sequence
A Collection Sequence classification object.
collection Collection
A Collection classification object.
condition Condition
A Condition classification object.
field_source Field Source
Defines actions to be taken to populate missing fields.
lexicon Lexicon
A Lexicon classification object.
lexicon_expression Lexicon Expression
A Lexicon Expression classification object.

This API returns a JSON response that is described by the model below. This single model is presented both as an easy to read abstract definition and as the formal JSON schema.

Asynchronous Use

Additional requests are required to get the result if this API is invoked asynchronously.

You can use /1/job/status/<job-id> to get the status of the job, including results if the job is finished.

You can also use /1/job/result/<job-id>, which waits until the job has finished and then returns the result.

Model
This is an abstract definition of the response that describes each of the properties that might be returned.
Update Classification Response {
One of the following: Collection_sequence or Collection or Condition or Lexicon or Lexicon_expression or Field_source
additional ( object , optional) JSON formatted additional information depending on the object type. See the schema for more details
description ( , optional) The description of the classification object.
id ( number ) The ID of the classification object.
name ( string ) The name of the classification object.
type ( enum<Type> ) The type of the classification object.
}
enum<Update Classification Response:Type> {
'collection_sequence' , 'collection' , 'condition' , 'lexicon' , 'lexicon_expression' , 'field_source'
}
Collection_sequence {
additional ( Additional , optional)
type ( enum<Type> , optional)
}
enum<Collection_sequence:Type> {
'collection_sequence'
}
Collection_sequence:Additional {
collection_sequence_entries ( , optional) Use undefined or null when updating to leave unmodified. Use empty array to remove all.
default_collection_id ( , optional)
full_condition_evaluation ( boolean , optional) True causes all conditions within a Boolean OR condition to be evaluated instead of stopping after the first matching condition.
}
Collection {
additional ( Additional , optional)
type ( enum<Type> , optional)
}
enum<Collection:Type> {
'collection'
}
Collection:Additional {
condition ( Condition , optional) A condition.
policy_ids ( , optional) Use undefined or null when updating to leave unmodified. Use empty array to remove all.
}
Condition {
additional ( Additional )
type ( enum<Type> , optional)
}
enum<Condition:Type> {
'condition'
}
Condition:Additional {
One of the following: Boolean_condition or Regex_condition or Date_condition or Exists_condition or Fragment_condition or Lexicon_condition or Not_condition or Number_condition or String_condition or Text_condition
include_descendants ( boolean , optional) Include descendants in the evaluation or just direct children. Only used when the target is all and children.
notes ( , optional) Notes about the condition.
target ( enum<Target> , optional) The target for the condition. Default is container.
type ( enum<Type> ) Readonly.
}
enum<Condition:Additional:Target> {
'all' , 'children' , 'container'
}
enum<Condition:Additional:Type> {
'boolean' , 'regex' , 'date' , 'fragment' , 'lexicon' , 'not' , 'number' , 'string' , 'exists' , 'text'
}
Boolean_condition {
children ( , optional) Use undefined or null when updating to leave unmodified. Use empty array to remove all.
operator ( string ) 'or' means only one child must match for this condition to match, 'and' requires all child conditions to match.
type ( enum<Type> , optional)
}
enum<Boolean_condition:Type> {
'boolean'
}
Regex_condition {
field ( string )
language ( , optional) The expected language of the content.
type ( enum<Type> , optional)
value ( string ) A regular expression.
}
enum<Regex_condition:Type> {
'regex'
}
Date_condition {
field ( string )
operator ( enum<Operator> )
type ( enum<Type> , optional)
value ( string ) The date value to check content against.
}
enum<Date_condition:Operator> {
'before' , 'after' , 'on'
}
enum<Date_condition:Type> {
'date'
}
Exists_condition {
field ( string )
type ( enum<Type> , optional)
}
enum<Exists_condition:Type> {
'exists'
}
Fragment_condition {
type ( enum<Type> , optional)
value ( number )
}
enum<Fragment_condition:Type> {
'fragment'
}
Lexicon_condition {
field ( string )
type ( enum<Type> , optional)
value ( number )
}
enum<Lexicon_condition:Type> {
'lexicon'
}
Not_condition {
condition ( Condition , optional)
type ( enum<Type> , optional)
}
enum<Not_condition:Type> {
'not'
}
Number_condition {
field ( string )
operator ( enum<Operator> )
type ( enum<Type> , optional)
value ( number ) Number to check content against.
}
enum<Number_condition:Operator> {
'gt' , 'lt' , 'eq'
}
enum<Number_condition:Type> {
'number'
}
String_condition {
field ( string )
operator ( enum<Operator> )
type ( enum<Type> , optional)
value ( string ) String value to compare against content.
}
enum<String_condition:Operator> {
'is' , 'starts_with' , 'ends_with'
}
enum<String_condition:Type> {
'string'
}
Text_condition {
field ( string )
language ( , optional) The language of the content.
type ( enum<Type> , optional)
value ( string ) The text expression to check content against.
}
enum<Text_condition:Type> {
'text'
}
Lexicon {
additional ( Additional , optional)
type ( enum<Type> , optional)
}
enum<Lexicon:Type> {
'lexicon'
}
Lexicon:Additional {
lexicon_expressions ( array[Lexicon_expression] , optional) List of expressions in the lexicon.
}
Lexicon_expression {
additional ( Additional , optional)
type ( enum<Type> , optional)
}
enum<Lexicon_expression:Type> {
'lexicon_expression'
}
Lexicon_expression:Additional {
expression ( string ) The regular or text expression.
lexicon_id ( number ) ID of the parent lexicon.
type ( enum<Type> )
}
enum<Lexicon_expression:Additional:Type> {
'regex' , 'text'
}
Field_source {
additional ( Additional , optional)
type ( enum<Type> , optional)
}
enum<Field_source:Type> {
'field_source'
}
Field_source:Additional {
field_type ( string , optional)
source_arguments ( Source_arguments , optional) The arguments for the field source.
}
Field_source:Additional:Source_arguments {
eduction ( , optional)
eduction_onpremise ( , optional)
fields ( , optional)
}
Model Schema
This is a JSON schema that describes the syntax of the response. See json-schema.org for a complete reference.
{
    "definitions": {
        "boolean_condition": {
            "properties": {
                "children": {
                    "items": {
                        "$ref": "#/definitions/condition"
                    },
                    "type": [
                        "array",
                        "null"
                    ]
                },
                "operator": {
                    "enum": [
                        "and",
                        "or"
                    ],
                    "type": "string"
                },
                "type": {
                    "enum": [
                        "boolean"
                    ]
                }
            },
            "required": [
                "operator"
            ],
            "type": "object"
        },
        "collection": {
            "properties": {
                "additional": {
                    "properties": {
                        "condition": {
                            "$ref": "#/definitions/condition"
                        },
                        "policy_ids": {
                            "items": {
                                "multipleOf": 1,
                                "type": "number"
                            },
                            "type": [
                                "array",
                                "null"
                            ]
                        }
                    },
                    "type": "object"
                },
                "type": {
                    "enum": [
                        "collection"
                    ]
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "collection_sequence": {
            "properties": {
                "additional": {
                    "properties": {
                        "collection_sequence_entries": {
                            "items": {
                                "$ref": "#/definitions/collection_sequence_entry"
                            },
                            "type": [
                                "array",
                                "null"
                            ]
                        },
                        "default_collection_id": {
                            "multipleOf": 1,
                            "type": [
                                "number",
                                "null"
                            ]
                        },
                        "full_condition_evaluation": {
                            "type": "boolean"
                        }
                    },
                    "type": "object"
                },
                "type": {
                    "enum": [
                        "collection_sequence"
                    ]
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "collection_sequence_entry": {
            "properties": {
                "collection_ids": {
                    "items": {
                        "multipleOf": 1,
                        "type": "number"
                    },
                    "type": [
                        "array",
                        "null"
                    ]
                },
                "order": {
                    "multipleOf": 1,
                    "type": "number"
                },
                "stop_on_match": {
                    "type": "boolean"
                }
            },
            "type": "object"
        },
        "condition": {
            "properties": {
                "additional": {
                    "oneOf": [
                        {
                            "$ref": "#/definitions/boolean_condition"
                        },
                        {
                            "$ref": "#/definitions/regex_condition"
                        },
                        {
                            "$ref": "#/definitions/date_condition"
                        },
                        {
                            "$ref": "#/definitions/exists_condition"
                        },
                        {
                            "$ref": "#/definitions/fragment_condition"
                        },
                        {
                            "$ref": "#/definitions/lexicon_condition"
                        },
                        {
                            "$ref": "#/definitions/not_condition"
                        },
                        {
                            "$ref": "#/definitions/number_condition"
                        },
                        {
                            "$ref": "#/definitions/string_condition"
                        },
                        {
                            "$ref": "#/definitions/text_condition"
                        }
                    ],
                    "properties": {
                        "include_descendants": {
                            "type": "boolean"
                        },
                        "notes": {
                            "type": [
                                "string",
                                "null"
                            ]
                        },
                        "target": {
                            "enum": [
                                "all",
                                "children",
                                "container"
                            ]
                        },
                        "type": {
                            "enum": [
                                "boolean",
                                "regex",
                                "date",
                                "fragment",
                                "lexicon",
                                "not",
                                "number",
                                "string",
                                "exists",
                                "text"
                            ]
                        }
                    },
                    "required": [
                        "type"
                    ],
                    "type": "object"
                },
                "type": {
                    "enum": [
                        "condition"
                    ]
                }
            },
            "required": [
                "additional"
            ],
            "type": "object"
        },
        "date_condition": {
            "properties": {
                "field": {
                    "$ref": "#/definitions/field"
                },
                "operator": {
                    "enum": [
                        "before",
                        "after",
                        "on"
                    ]
                },
                "type": {
                    "enum": [
                        "date"
                    ]
                },
                "value": {
                    "minLength": 1,
                    "type": "string"
                }
            },
            "required": [
                "field",
                "value",
                "operator"
            ],
            "type": "object"
        },
        "exists_condition": {
            "properties": {
                "field": {
                    "$ref": "#/definitions/field"
                },
                "type": {
                    "enum": [
                        "exists"
                    ]
                }
            },
            "required": [
                "field"
            ],
            "type": "object"
        },
        "field": {
            "minLength": 1,
            "type": "string"
        },
        "field_source": {
            "properties": {
                "additional": {
                    "properties": {
                        "field_type": {
                            "enum": [
                                "date",
                                "number",
                                "string"
                            ],
                            "type": "string"
                        },
                        "source_arguments": {
                            "properties": {
                                "eduction": {
                                    "items": {
                                        "$ref": "#/definitions/eduction"
                                    },
                                    "type": [
                                        "array",
                                        "null"
                                    ]
                                },
                                "eduction_onpremise": {
                                    "items": {
                                        "$ref": "#/definitions/eduction_onpremise"
                                    },
                                    "type": [
                                        "array",
                                        "null"
                                    ]
                                },
                                "fields": {
                                    "items": {
                                        "type": "string"
                                    },
                                    "type": [
                                        "array",
                                        "null"
                                    ]
                                }
                            },
                            "type": "object"
                        }
                    },
                    "type": "object"
                },
                "type": {
                    "enum": [
                        "field_source"
                    ]
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "fragment_condition": {
            "properties": {
                "type": {
                    "enum": [
                        "fragment"
                    ]
                },
                "value": {
                    "multipleOf": 1,
                    "type": "number"
                }
            },
            "required": [
                "value"
            ],
            "type": "object"
        },
        "lexicon": {
            "properties": {
                "additional": {
                    "properties": {
                        "lexicon_expressions": {
                            "items": {
                                "$ref": "#/definitions/lexicon_expression"
                            },
                            "type": "array"
                        }
                    },
                    "type": "object"
                },
                "type": {
                    "enum": [
                        "lexicon"
                    ]
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "lexicon_condition": {
            "properties": {
                "field": {
                    "$ref": "#/definitions/field"
                },
                "type": {
                    "enum": [
                        "lexicon"
                    ]
                },
                "value": {
                    "multipleOf": 1,
                    "type": "number"
                }
            },
            "required": [
                "field",
                "value"
            ],
            "type": "object"
        },
        "lexicon_expression": {
            "properties": {
                "additional": {
                    "properties": {
                        "expression": {
                            "minLength": 1,
                            "type": "string"
                        },
                        "lexicon_id": {
                            "multipleOf": 1,
                            "type": "number"
                        },
                        "type": {
                            "enum": [
                                "regex",
                                "text"
                            ]
                        }
                    },
                    "required": [
                        "lexicon_id",
                        "type",
                        "expression"
                    ],
                    "type": "object"
                },
                "type": {
                    "enum": [
                        "lexicon_expression"
                    ]
                }
            },
            "type": "object"
        },
        "not_condition": {
            "properties": {
                "condition": {
                    "$ref": "#/definitions/condition"
                },
                "type": {
                    "enum": [
                        "not"
                    ]
                }
            },
            "type": "object"
        },
        "number_condition": {
            "properties": {
                "field": {
                    "$ref": "#/definitions/field"
                },
                "operator": {
                    "enum": [
                        "gt",
                        "lt",
                        "eq"
                    ]
                },
                "type": {
                    "enum": [
                        "number"
                    ]
                },
                "value": {
                    "multipleOf": 1,
                    "type": "number"
                }
            },
            "required": [
                "field",
                "value",
                "operator"
            ],
            "type": "object"
        },
        "regex_condition": {
            "properties": {
                "field": {
                    "$ref": "#/definitions/field"
                },
                "language": {
                    "type": [
                        "string",
                        "null"
                    ]
                },
                "type": {
                    "enum": [
                        "regex"
                    ]
                },
                "value": {
                    "minLength": 1,
                    "type": "string"
                }
            },
            "required": [
                "field",
                "value"
            ],
            "type": "object"
        },
        "string_condition": {
            "properties": {
                "field": {
                    "$ref": "#/definitions/field"
                },
                "operator": {
                    "enum": [
                        "is",
                        "starts_with",
                        "ends_with"
                    ]
                },
                "type": {
                    "enum": [
                        "string"
                    ]
                },
                "value": {
                    "type": "string"
                }
            },
            "required": [
                "field",
                "value",
                "operator"
            ],
            "type": "object"
        },
        "text_condition": {
            "properties": {
                "field": {
                    "$ref": "#/definitions/field"
                },
                "language": {
                    "type": [
                        "string",
                        "null"
                    ]
                },
                "type": {
                    "enum": [
                        "text"
                    ]
                },
                "value": {
                    "type": "string"
                }
            },
            "required": [
                "field",
                "value"
            ],
            "type": "object"
        }
    },
    "oneOf": [
        {
            "$ref": "#/definitions/collection_sequence"
        },
        {
            "$ref": "#/definitions/collection"
        },
        {
            "$ref": "#/definitions/condition"
        },
        {
            "$ref": "#/definitions/lexicon"
        },
        {
            "$ref": "#/definitions/lexicon_expression"
        },
        {
            "$ref": "#/definitions/field_source"
        }
    ],
    "properties": {
        "additional": {
            "type": "object"
        },
        "id": {
            "multipleOf": 1,
            "type": "number"
        },
        "name": {
            "minLength": 1,
            "type": "string"
        },
        "type": {
            "enum": [
                "collection_sequence",
                "collection",
                "condition",
                "lexicon",
                "lexicon_expression",
                "field_source"
            ]
        }
    },
    "required": [
        "id",
        "name",
        "type"
    ],
    "type": "object"
}


If you would like to provide us with more information then please use the box below:

We will use your submission to help improve our product.