# Pre-Configured Operators
This documentation provides a comprehensive reference to the predefined operators available in our platform. These operators enable users to construct precise and reusable expressions that evaluate data based on a wide variety of conditions, including comparisons, existence checks, string operations, numeric ranges, and date-time logic.
## Operator Reference at a Glance
The table below categorizes and summarizes all predefined operators available in the system. Operators are grouped by data type and use case, making it easy to identify the right tool for your logic. Use this quick reference to explore the available conditions before diving into detailed behavior and examples in the following sections.
| Category | Operator | Description |
| ------------------ | -------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| **Common/Generic** | **Any** | Passes if any condition in a group evaluates to true. |
| | **Exists** | Checks if the field or key is present and has a non-null value. |
| | **Doesn’t Exist** | Passes if the field or key is missing or undefined. |
| | **Is Null** | Returns true if the value is exactly null. |
| | **Is not Null** | Returns true if the value is not null. |
| **Number** | **Between Inclusive** | Validates if the number falls inside a specified inclusive range, including both boundary values. |
| | **Not Between** | Validates if the number falls outside a specified inclusive range (i.e. ≤ lower bound or ≥ upper bound). |
| | **Between Exclusive** | Validates if the number falls inside a specified exclusive range, excluding both boundary values. |
| | **Equals** | Checks if the number is exactly equal to the given value. |
| | **Not Equals** | Checks if the number is not equal to the specified value. |
| | **Greater than** | Passes if the number is strictly greater than the specified value. |
| | **Less than** | Passes if the number is strictly less than the specified value. |
| | **Greater than or equals** | Passes if the number is greater than or equal to the given value. |
| | **Less than or equals** | Passes if the number is less than or equal to the given value. |
| | **Is Even** | Checks if the number is divisible by 2 with no remainder. |
| | **Is Odd** | Passes if the number is not divisible by 2. |
| | **In** | Checks if the number matches any value in a given list. |
| | **Not In** | Passes if the number does not match any value in a given list. |
| **String** | **Equals** | Returns true if the strings are an exact match. |
| | **Not Equals** | Returns true if the strings do not match exactly. |
| | **Contains** | Checks if the string includes the specified substring. |
| | **Does not Contains** | Returns true if the string does not contain the specified substring. |
| | **Starts With** | Validates if the string begins with the given prefix. |
| | **Does not start with** | Passes if the string does not begin with the given prefix. |
| | **Ends with** | Returns true if the string ends with the specified suffix. |
| | **Doesn’t Ends with** | Passes if the string does not end with the given suffix. |
| | **Is IN** | Checks if the string matches any value in a given list. |
| | **IS NOT IN** | Passes if the string does not match any value in a given list. |
| | **Is Empty** | Returns true if the string is either empty ("") or has zero length. |
| | **Is not Empty** | Returns true if the string has at least one character. |
| | **In Text** | Checks if the string contains the specified substring. |
| | **Not In Text** | Returns true if the string does not contain the specified substring. |
| | **Includes All Words** | Passes if the string contains all the words provided in the list. |
| | **Includes Any Words** | Passes if the string contains at least one word from the provided list. |
| | **Includes No Words** | Returns true if the string contains none of the words in the provided list. |
| | **Contains In Any Item** | Checks if the string contains the specified substring in any item of a list. |
| | **Contains In No Item** | Returns true if the string does not contain the specified substring in any item of a list. |
| | **Regex Match** | Validates if the string matches a specified regular expression pattern. |
| | **Regex Not Match** | Returns true if the string does not match the specified regular expression pattern. |
| **Dates/DateTime** | **Between Inclusive** | Validates if the date/time falls within an inclusive range, including both start and end points. |
| | **Not Between** | Validates if the date/time lies outside an inclusive range (i.e. on or before the start, or on or after the end). |
| | **Between Exclusive** | Validates if the date/time falls within an exclusive range, excluding both start and end points. |
| | **Equals** | Passes if both dates or timestamps are identical. |
| | **Not Equals** | Passes if the values differ. |
| | **Greater than** | Validates if the date/time is later than the comparison value. |
| | **Less than** | Passes if the date/time is earlier than the comparison value. |
| | **Greater than or equals** | Returns true if the date/time is on or after the given date/time. |
| | **Less than or equals** | Returns true if the date/time is on or before the given date/time. |
| | **In** | Checks if the date/time matches any value in a given list. |
| | **Not In** | Passes if the date/time does not match any value in a given list. |
| **Boolean** | **Is False** | Passes if the value is strictly false. |
| | **Is True** | Passes if the value is strictly true. |
| | **In** | Checks if the boolean value matches any value in a given list. |
| | **Not In** | Passes if the boolean value does not match any value in a given list. |
### Common / Generic Operators
These operators apply to any data type and are often used for basic checks like value presence or nullability. They help ensure that required fields are available and allow you to build general-purpose conditions across fields of varying types.
#### Any
The `Any` operator passes if the selected property has **any value** — regardless of its type or specific content. It is useful when the condition should succeed as long as the field is not missing or undefined.
**Example (Pseudocode):**
```
Field: creditApplicationStatus
Operator: Any
```
**Result:** Passes if `creditApplicationStatus` has any value (e.g., `"PENDING"`, `123`, `true`, etc.).
#### Exists
The `Exists` operator checks whether the field or key is present and not `null` or `undefined`. It is typically used to confirm that a value has been supplied for a field.
**Example (Pseudocode):**
```
Field: applicant.age
Operator: Exists
```
**Result:** Passes if `applicant.age` is present in the data and not `null`.
#### Doesn’t Exist
The `Doesn’t Exist` operator passes if the field is **not present** or is explicitly `undefined`. Use this to identify optional or missing fields.
**Example (Pseudocode):**
```
Field: applicant.phone
Operator: Doesn’t Exist
```
**Result:** Passes if `applicant.phone` is not defined in the data.
#### Is Null
The `Is Null` operator returns true when the field exists and its value is explicitly `null`. This is distinct from being `undefined` or missing entirely.
**Example (Pseudocode):**
```
Field: middle_name
Operator: Is Null
```
**Result:** Passes if the value is exactly `null`, as in `"middle_name": null`.
#### Is Not Null
The `Is Not Null` operator passes when the field's value is **not** `null`. The field must exist and have any value other than `null`, including empty strings or zeroes.
**Example (Pseudocode):**
```
Field: applicant.email
Operator: Is Not Null
```
**Result:** Passes if `"applicant.email"` exists and is not `null`.
### Number Operators
Number operators are used to evaluate numeric fields against specific values or ranges. These operators support precise mathematical comparisons and help you define conditions for thresholds, limits, or specific numeric states such as evenness.
#### Between Inclusive
The `Between Inclusive` operator passes if the field's value falls **within** a specified inclusive range.
**Example (Pseudocode):**
```
Field: applicant.age
Operator: Between
Value: 18 to 25
```
**Result:** Passes if the age is between 18 and 25, inclusive (e.g., 18, 19, ..., 25).
\
#### Not Between
The `Not Between` operator passes if the field’s value lies **outside** the specified range.
**Example (Pseudocode):**
```
Field: creditScore
Operator: Not Between
Value: 600 to 700
```
**Result:** Passes if the score is less than 600 or greater than 700.
#### Equals
The `Equals` operator passes if the field’s numeric value is **exactly equal** to the specified value.
**Example (Pseudocode):**
```
Field: loanTermMonths
Operator: Equals
Value: 36
```
**Result:** Passes only if the value is exactly 36.
#### Not Equals
The `Not Equals` operator passes if the numeric value does **not** match the given value.
**Example (Pseudocode):**
```
Field: installmentCount
Operator: Not Equals
Value: 12
```
**Result:** Passes if the value is anything except 12.
#### Greater Than
The `Greater Than` operator passes if the value is **strictly greater than** the specified number.
**Example (Pseudocode):**
```
Field: income
Operator: Greater Than
Value: 50000
```
**Result:** Passes if `income > 50000`.
#### Less Than
The `Less Than` operator passes if the value is **strictly less than** the given number.
**Example (Pseudocode):**
```
Field: debtAmount
Operator: Less Than
Value: 10000
```
**Result:** Passes if `debtAmount < 10000`.
#### Greater Than or Equals
The `Greater Than or Equals` operator passes if the value is **equal to or greater than** the specified threshold.
**Example (Pseudocode):**
```
Field: savings
Operator: Greater Than or Equals
Value: 2000
```
**Result:** Passes if `savings >= 2000`.
#### Less Than or Equals
The `Less Than or Equals` operator passes if the value is **equal to or less than** the given number.
**Example (Pseudocode):**
```
Field: monthlyExpense
Operator: Less Than or Equals
Value: 3000
```
**Result:** Passes if `monthlyExpense <= 3000`.
#### Is Even
The `Is Even` operator checks if the numeric value is divisible by 2 with no remainder.
**Example (Pseudocode):**
```
Field: numberOfDependents
Operator: Is Even
```
**Result:** Passes if the value is 0, 2, 4, 6, etc.
#### Is Odd
The `Is Odd` operator passes if the value is **not evenly divisible** by 2.
**Example (Pseudocode):**
```
Field: retryAttempts
Operator: Is Odd
```
**Result:** Passes if the value is 1, 3, 5, etc.
#### In
The `In` operator passes if the numeric value **matches any value** from a specified list.
**Example (Pseudocode):**
```
Field: statusCode
Operator: In
Value: [200, 201, 204]
```
**Result:** Passes if the status code is one of the listed values.
#### Not In
The `Not In` operator passes if the numeric value **does not match any** value in the list.
**Example (Pseudocode):**
```
Field: errorCode
Operator: Not In
Value: [404, 500, 503]
```
**Result:** Passes if the error code is not one of the listed values.
#### Between Exclusive
The `Between Exclusive` operator passes if the field's value falls **within** a specified exclusive range, excluding both boundary values.
**Example (Pseudocode):**
```
Field: applicant.age
Operator: Between Exclusive
Value: 18 to 65
```
**Result:** Passes if the age is greater than 18 and less than 65 (e.g., 19, 20, ..., 64).
⚙ This operator is exclusive, meaning both boundary values are excluded. For example, if the range is defined as 1 to 10, the condition will pass for any value strictly between 1 and 10, but not for 1 or 10 themselves.
### String Operators
String operators are used to evaluate text fields based on content, structure, and comparison. These operators allow you to match exact strings, check for substrings, and validate patterns like prefixes and suffixes — essential for working with names, IDs, statuses, and other textual data.
#### Equals
The `Equals` operator passes if the string value **exactly matches** the specified input, including case and spacing.
**Example (Pseudocode):**
```
Field: applicationStatus
Operator: Equals
Value: "Approved"
```
**Result:** Passes only if `applicationStatus` is exactly `"Approved"`.
#### Not Equals
The `Not Equals` operator passes if the string does **not** match the given input exactly.
**Example (Pseudocode):**
```
Field: applicationStatus
Operator: Not Equals
Value: "Rejected"
```
**Result:** Passes if the value is anything except `"Rejected"`.
#### Contains
The `Contains` operator checks if the string **includes** the specified substring anywhere within it.
**Example (Pseudocode):**
```
Field: address
Operator: Contains
Value: "Street"
```
**Result:** Passes if `address` contains "Street", such as "123 Main Street".
#### Does Not Contain
The `Does Not Contain` operator passes if the string **does not include** the specified substring.
**Example (Pseudocode):**
```
Field: address
Operator: Does Not Contain
Value: "PO Box"
```
**Result:** Passes if `address` does not contain "PO Box".
#### Starts With
The `Starts With` operator passes if the string begins with the specified prefix.
**Example (Pseudocode):**
```
Field: customerId
Operator: Starts With
Value: "CUST-"
```
**Result:** Passes if the value starts with "CUST-", such as "CUST-12345".
#### Does Not Start With
The `Does Not Start With` operator passes if the string does **not** begin with the specified prefix.
**Example (Pseudocode):**
```
Field: transactionId
Operator: Does Not Start With
Value: "TEMP-"
```
**Result:** Passes if the value does not start with "TEMP-".
#### Ends With
The `Ends With` operator checks if the string ends with the specified suffix.
**Example (Pseudocode):**
```
Field: email
Operator: Ends With
Value: "@example.com"
```
**Result:** Passes if the email ends with "@example.com".
#### Doesn’t End With
The `Doesn’t End With` operator passes if the string does **not** end with the specified suffix.
**Example (Pseudocode):**
```
Field: email
Operator: Doesn’t End With
Value: "@spam.com"
```
**Result:** Passes if the email does not end with "@spam.com".
#### Is In
The `Is In` operator passes if the string **matches any value** from a specified list.
**Example (Pseudocode):**
```
Field: currency
Operator: Is In
Value: ["USD", "EUR", "INR"]
```
**Result:** Passes if the currency is one of the listed options.
#### Is Not In
The `Is Not In` operator passes if the string **does not match any** value in the list.
**Example (Pseudocode):**
```
Field: status
Operator: Is Not In
Value: ["Inactive", "Disabled"]
```
**Result:** Passes if `status` is not "Inactive" or "Disabled".
#### Is Empty
The `Is Empty` operator passes if the string is either an empty string (`""`) or has zero length.
**Example (Pseudocode):**
```
Field: middleName
Operator: Is Empty
```
**Result:** Passes if `middleName` is set but contains no characters.
#### Is Not Empty
The `Is Not Empty` operator passes if the string has one or more characters.
**Example (Pseudocode):**
```
Field: firstName
Operator: Is Not Empty
```
**Result:** Passes if `firstName` is not an empty string.
Perfect — I’ll prepare both the **table-style list** and the **detailed descriptions** for your new string operators in the exact same format as your doc.
#### In Text
The **In Text** operator checks if the given string contains the specified substring.\
It is similar to “Contains,” but can be used more flexibly when matching textual values.
**Example (Pseudocode):**
```
Field: description
Operator: In Text
Value: "urgent"
Result: Passes if description includes "urgent" anywhere in the text.
```
#### Not In Text
The **Not In Text** operator passes if the given string does not contain the specified substring.
**Example (Pseudocode):**
```
Field: notes
Operator: Not In Text
Value: "spam"
Result: Passes if notes does not contain the word "spam".
```
#### Includes All Words
The **Includes All Words** operator checks if the string contains **every word** from the provided list, regardless of order.
**Example (Pseudocode):**
```
Field: feedback
Operator: Includes All Words
Value: ["fast", "reliable"]
Result: Passes if feedback contains both "fast" and "reliable".
```
#### Includes Any Words
The **Includes Any Words** operator passes if the string contains **at least one** word from the provided list.
**Example (Pseudocode):**
```
Field: productReview
Operator: Includes Any Words
Value: ["cheap", "affordable", "budget"]
Result: Passes if productReview contains any one of these words.
```
#### Includes No Words
The **Includes No Words** operator returns true if the string contains **none** of the words in the list.
**Example (Pseudocode):**
```
Field: comment
Operator: Includes No Words
Value: ["error", "issue", "problem"]
Result: Passes only if comment does not contain any of these words.
```
#### Contains In Any Item
The `Contains In Any Item` operator checks if the string **contains the specified substring** in any item of a list. This is useful when working with array fields where each element is a string.
**Example (Pseudocode):**
```
Field: tags
Operator: Contains In Any Item
Value: "urgent"
```
**Result:** Passes if any tag in the list contains "urgent" as a substring.
#### Contains In No Item
The `Contains In No Item` operator passes if the string **does not contain the specified substring** in any item of a list.
**Example (Pseudocode):**
```
Field: tags
Operator: Contains In No Item
Value: "deprecated"
```
**Result:** Passes if none of the tags in the list contain "deprecated" as a substring.
#### Regex Match
The `Regex Match` operator validates if the string matches a specified regular expression pattern.
**Example (Pseudocode):**
```
Field: email
Operator: Regex Match
Value: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
```
**Result:** Passes if the email matches the regular expression pattern.
#### Regex Not Match
The `Regex Not Match` operator passes if the string **does not match** the specified regular expression pattern.
**Example (Pseudocode):**
```
Field: phoneNumber
Operator: Regex Not Match
Value: "^\d{10}$"
```
**Result:** Passes if the phone number does not match the 10-digit pattern.
### Date / DateTime Operators
Date and DateTime operators allow you to compare temporal values, such as submission dates, due dates, or timestamps of events. These operators support a wide range of date formats and offer precise control for rule conditions that involve scheduling, expiration, or chronological evaluation.
#### Supported Date Formats
The platform supports multiple regional and international date-time formats, including:
* **International / Regional:**
`mm/dd/yyyy hh:mm:ss`, `dd/mm/yyyy`, `mm-dd-yyyy`, etc.
* **ISO (Default):**
`yyyy-mm-dd'T'hh:mm:ssZ`, `yyyy-mm-dd hh:mm:ss`, `yyyy/mm/dd`, etc.
By default, **ISO format** is used across the UI, execution logs, and new rule/workflow creation. This format is recommended for reliability, especially in API and database interactions. Format settings apply to new content only; existing rules retain their original formats.
#### Between Inclusive
The `Between Inclusive` operator passes if the date or datetime value lies **within** a given start and end range (inclusive).
**Example (Pseudocode):**
```
Field: applicationDate
Operator: Between Inclusive
Value: 2023-01-01 to 2023-12-31
```
**Result:** Passes if `applicationDate` is within 2023, including January 1st and December 31st.
\
#### Not Between
The `Not Between` operator passes if the date or datetime value lies **outside** the specified range.
**Example (Pseudocode):**
```
Field: renewalDate
Operator: Not Between
Value: 2024-01-01 to 2024-03-31
```
**Result:** Passes if `renewalDate` is before January 1st or after March 31st, 2024.
#### Equals
The `Equals` operator passes if the field’s value matches the specified date or timestamp **exactly** (to the second or full precision based on format).
**Example (Pseudocode):**
```
Field: scheduledAt
Operator: Equals
Value: 2025-06-05T10:00:00Z
```
**Result:** Passes if `scheduledAt` matches that exact timestamp.
#### Not Equals
The `Not Equals` operator passes if the field’s date/time value does **not** match the specified one.
**Example (Pseudocode):**
```
Field: createdAt
Operator: Not Equals
Value: 2025-01-01
```
**Result:** Passes if `createdAt` is any date other than January 1st, 2025.
#### Greater Than
The `Greater Than` operator passes if the field’s value is **after** the specified date/time.
**Example (Pseudocode):**
```
Field: paymentDue
Operator: Greater Than
Value: 2025-06-01
```
**Result:** Passes if `paymentDue` is later than June 1st, 2025.
#### Less Than
The `Less Than` operator passes if the date/time is **earlier than** the specified value.
**Example (Pseudocode):**
```
Field: submittedAt
Operator: Less Than
Value: 2025-05-01
```
**Result:** Passes if the submission occurred before May 1st, 2025.
#### Greater Than or Equals
The `Greater Than or Equals` operator passes if the date/time is on or **after** the specified value.
**Example (Pseudocode):**
```
Field: lastLogin
Operator: Greater Than or Equals
Value: 2025-01-01
```
**Result:** Passes if the login was on or after January 1st, 2025.
#### Less Than or Equals
The `Less Than or Equals` operator passes if the date/time is on or **before** the specified value.
**Example (Pseudocode):**
```
Field: expiryDate
Operator: Less Than or Equals
Value: 2025-12-31
```
**Result:** Passes if the expiry is before or on December 31st, 2025.
#### Between Exclusive
The `Between Exclusive` operator passes if the date or datetime value lies **within** a given start and end range (exclusive), excluding both boundary values.
**Example (Pseudocode):**
```
Field: applicationDate
Operator: Between Exclusive
Value: 2023-01-01 to 2023-12-31
```
**Result:** Passes if `applicationDate` is strictly between January 1st and December 31st, 2023 (not including those dates).
\
#### In
The `In` operator passes if the date or datetime value **matches any value** from a specified list.
**Example (Pseudocode):**
```
Field: holidayDate
Operator: In
Value: ["2025-01-01", "2025-07-04", "2025-12-25"]
```
**Result:** Passes if the holiday date is one of the listed dates.
#### Not In
The `Not In` operator passes if the date or datetime value **does not match any** value in the list.
**Example (Pseudocode):**
```
Field: blackoutDate
Operator: Not In
Value: ["2025-12-25", "2026-01-01"]
```
**Result:** Passes if the blackout date is not one of the listed dates.
### Boolean Operators
Boolean operators are used to evaluate fields that hold binary truth values — typically `true` or `false`. These operators are ideal for flags, switches, status fields, or any data point that represents a yes/no or on/off state.
Boolean values are expected to be stored in a strict Boolean format (`true` or `false`, not string equivalents like `"true"` or `"false"`). Any comparison against a non-Boolean value will not yield a match.
#### Is True
The `Is True` operator passes if the field's value is exactly `true`.
**Example (Pseudocode):**
```
Field: isVerified
Operator: Is True
```
**Result:** Passes if `isVerified` is set to `true`.
#### Is False
The `Is False` operator passes if the field's value is exactly `false`.
**Example (Pseudocode):**
```
Field: isOverdue
Operator: Is False
```
**Result:** Passes if `isOverdue` is explicitly `false`.
#### In
The `In` operator passes if the boolean value **matches any value** from a specified list.
**Example (Pseudocode):**
```
Field: isActive
Operator: In
Value: [true]
```
**Result:** Passes if `isActive` is `true`.
#### Not In
The `Not In` operator passes if the boolean value **does not match any** value in the list.
**Example (Pseudocode):**
```
Field: isDisabled
Operator: Not In
Value: [true]
```
**Result:** Passes if `isDisabled` is `false`.
***
These operators serve as the foundation for expressing conditional logic across a wide variety of data types — including strings, numbers, dates, date-times, and booleans.
For additional support or use case-specific guidance, refer to the platform's rule builder documentation or contact your technical enablement team.