{
    "$schema": "http://json-schema.org/draft-04/schema#",
    "type": "object",
    "properties": {
        "rules": {
            "type": "object",
            "properties": {
                "@mr-linter/changed_files_limit": {
                    "description": "Check count changed files on a {limit}.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_changed_files_limit"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_changed_files_limit"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/description_contains_links_of_any_domains": {
                    "description": "Merge Request must contain links of any {domains}.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_description_contains_links_of_any_domains"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_description_contains_links_of_any_domains"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/description_contains_links_of_all_domains": {
                    "description": "Merge Request must contain links of all {domains}.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_description_contains_links_of_all_domains"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_description_contains_links_of_all_domains"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/description_not_empty": {
                    "description": "The description must be filled.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_description_not_empty"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_description_not_empty"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/has_any_labels": {
                    "description": "Merge Request must have any {labels}.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_has_any_labels"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_has_any_labels"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/jira/has_issue_link": {
                    "description": "The description must have a link to Jira on a {domain} with {projectCode}.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_jira_has_issue_link"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_jira_has_issue_link"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/youtrack/has_issue_link": {
                    "description": "The description must have a link to YouTrack issue on a {domain} with {projectCode}.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_youtrack_has_issue_link"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_youtrack_has_issue_link"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/title_must_starts_with_any_prefix": {
                    "description": "The title must starts with any {prefixes}",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_title_must_starts_with_any_prefix"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_title_must_starts_with_any_prefix"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/has_changes": {
                    "description": "Merge Request must have {changes}.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_has_changes"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_has_changes"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "custom": {
                    "description": "Custom Rule for Users.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_custom"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_custom"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/title_starts_with_task_number": {
                    "description": "Title must starts with task number of project {projectCodes}. Mask: {projectCode}-number",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_title_starts_with_task_number"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_title_starts_with_task_number"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/branch_starts_with_task_number": {
                    "description": "Source branch must starts with task number of project {projectCodes}. Mask: {projectCode}-number",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_branch_starts_with_task_number"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_branch_starts_with_task_number"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/forbid_changes": {
                    "description": "Forbid changes for files.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_forbid_changes"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_forbid_changes"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/changelog_has_new_release": {
                    "description": "Changelog must be contained new release.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_changelog_has_new_release"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_changelog_has_new_release"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/diff_limit": {
                    "description": "The request must contain no more than {linesMax} changes.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_diff_limit"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_diff_limit"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/no_ssh_keys": {
                    "description": "Prevent ssh keys from being included in the merge request.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_no_ssh_keys"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_no_ssh_keys"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/disable_file_extensions": {
                    "description": "Disable adding files of certain extensions.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_disable_file_extensions"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_disable_file_extensions"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/title_conventional": {
                    "description": "The title must match conventional commit pattern https://www.conventionalcommits.org/en/v1.0.0.",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_title_conventional"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_title_conventional"
                            },
                            "minItems": 1
                        }
                    ]
                },
                "@mr-linter/description_template": {
                    "description": "The description must match defined template. Available placeholders: {text}, {text_multiline}, {number}, {word}, {release_tag}",
                    "oneOf": [
                        {
                            "$ref": "#/definitions/rules_properties_@mr-linter_description_template"
                        },
                        {
                            "type": "array",
                            "items": {
                                "$ref": "#/definitions/rules_properties_@mr-linter_description_template"
                            },
                            "minItems": 1
                        }
                    ]
                }
            },
            "additionalProperties": false
        },
        "comments": {
            "type": "object",
            "properties": {
                "strategy": {
                    "type": "string",
                    "enum": [
                        "single",
                        "single_append",
                        "null",
                        "new"
                    ]
                },
                "messages": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "template": {
                                "type": "string"
                            },
                            "when": {
                                "properties": {
                                    "request.title": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "lengthMin": {
                                                "description": "Check the minimum string length.",
                                                "type": "integer"
                                            },
                                            "lengthMax": {
                                                "description": "Check the maximum string length.",
                                                "type": "integer"
                                            },
                                            "starts": {
                                                "description": "Check if a string contains a prefix.",
                                                "type": "string"
                                            },
                                            "notStarts": {
                                                "description": "Check if a string not contains a prefix.",
                                                "type": "string"
                                            },
                                            "ends": {
                                                "description": "Check if a string contains a suffix.",
                                                "type": "string"
                                            },
                                            "notEnds": {
                                                "description": "Check if a string not contains a suffix.",
                                                "type": "string"
                                            },
                                            "contains": {
                                                "description": "Check if a string contains a substring.",
                                                "type": "string"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "equalsAny": {
                                                "description": "Check if the field is equal to one of the values.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "match": {
                                                "description": "Check if a string match a regex.",
                                                "type": "string"
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "isCamelCase": {
                                                "description": "Check if a string is camelCase.",
                                                "type": "boolean"
                                            },
                                            "isStudlyCase": {
                                                "description": "Check if a string is StudlyCase.",
                                                "type": "boolean"
                                            },
                                            "isUpperCase": {
                                                "description": "Check if a string is upper case.",
                                                "type": "boolean"
                                            },
                                            "isLowerCase": {
                                                "description": "Check if a string is lower case.",
                                                "type": "boolean"
                                            },
                                            "isSnakeCase": {
                                                "description": "Check if a string is snake_case.",
                                                "type": "boolean"
                                            },
                                            "isKebabCase": {
                                                "description": "Check if a string is kebab-case.",
                                                "type": "boolean"
                                            },
                                            "linesMax": {
                                                "description": "Check the maximum string lines.",
                                                "type": "integer"
                                            },
                                            "containsLine": {
                                                "description": "Check if a string contains a line.",
                                                "type": "string"
                                            },
                                            "notStartsAny": {
                                                "description": "Check if a string not contains a prefixes.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isNumber": {
                                                "description": "Check if value are number.",
                                                "type": "boolean"
                                            },
                                            "containsNumber": {
                                                "description": "Check if value are contains number.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.descriptionMarkdown": {
                                        "type": "object",
                                        "properties": {
                                            "containsHeading1": {
                                                "description": "Check if a markdown-string contains a heading.",
                                                "type": "string"
                                            },
                                            "containsHeading2": {
                                                "description": "Check if a markdown-string contains a heading.",
                                                "type": "string"
                                            },
                                            "containsHeading3": {
                                                "description": "Check if a markdown-string contains a heading.",
                                                "type": "string"
                                            },
                                            "containsHeading4": {
                                                "description": "Check if a markdown-string contains a heading.",
                                                "type": "string"
                                            },
                                            "containsHeading5": {
                                                "description": "Check if a markdown-string contains a heading.",
                                                "type": "string"
                                            },
                                            "containsHeading6": {
                                                "description": "Check if a markdown-string contains a heading.",
                                                "type": "string"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.description": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "lengthMin": {
                                                "description": "Check the minimum string length.",
                                                "type": "integer"
                                            },
                                            "lengthMax": {
                                                "description": "Check the maximum string length.",
                                                "type": "integer"
                                            },
                                            "starts": {
                                                "description": "Check if a string contains a prefix.",
                                                "type": "string"
                                            },
                                            "notStarts": {
                                                "description": "Check if a string not contains a prefix.",
                                                "type": "string"
                                            },
                                            "ends": {
                                                "description": "Check if a string contains a suffix.",
                                                "type": "string"
                                            },
                                            "notEnds": {
                                                "description": "Check if a string not contains a suffix.",
                                                "type": "string"
                                            },
                                            "contains": {
                                                "description": "Check if a string contains a substring.",
                                                "type": "string"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "equalsAny": {
                                                "description": "Check if the field is equal to one of the values.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "match": {
                                                "description": "Check if a string match a regex.",
                                                "type": "string"
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "isCamelCase": {
                                                "description": "Check if a string is camelCase.",
                                                "type": "boolean"
                                            },
                                            "isStudlyCase": {
                                                "description": "Check if a string is StudlyCase.",
                                                "type": "boolean"
                                            },
                                            "isUpperCase": {
                                                "description": "Check if a string is upper case.",
                                                "type": "boolean"
                                            },
                                            "isLowerCase": {
                                                "description": "Check if a string is lower case.",
                                                "type": "boolean"
                                            },
                                            "isSnakeCase": {
                                                "description": "Check if a string is snake_case.",
                                                "type": "boolean"
                                            },
                                            "isKebabCase": {
                                                "description": "Check if a string is kebab-case.",
                                                "type": "boolean"
                                            },
                                            "linesMax": {
                                                "description": "Check the maximum string lines.",
                                                "type": "integer"
                                            },
                                            "containsLine": {
                                                "description": "Check if a string contains a line.",
                                                "type": "string"
                                            },
                                            "notStartsAny": {
                                                "description": "Check if a string not contains a prefixes.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isNumber": {
                                                "description": "Check if value are number.",
                                                "type": "boolean"
                                            },
                                            "containsNumber": {
                                                "description": "Check if value are contains number.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.labels": {
                                        "type": "object",
                                        "properties": {
                                            "countMin": {
                                                "description": "Check the minimum number of elements in a field.",
                                                "type": "integer"
                                            },
                                            "countMax": {
                                                "description": "Check the maximum number of elements in a field.",
                                                "type": "integer"
                                            },
                                            "countEquals": {
                                                "description": "Check count equals.",
                                                "type": "integer"
                                            },
                                            "countNotEquals": {
                                                "description": "Check count not equals.",
                                                "type": "integer"
                                            },
                                            "countEqualsAny": {
                                                "description": "Check count equals.",
                                                "type": "array",
                                                "items": {
                                                    "type": "integer"
                                                }
                                            },
                                            "has": {
                                                "description": "Check if an array contains some value.",
                                                "type": "string"
                                            },
                                            "notHas": {
                                                "description": "Check if an array not contains some value.",
                                                "type": "string"
                                            },
                                            "hasAny": {
                                                "description": "Check if an array contains some value of list.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "notHasAny": {
                                                "description": "Check if an array not contains values of list.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "$all": {
                                                "description": "True if all values of array matched conditions.",
                                                "type": "object",
                                                "properties": {
                                                    "equals": {
                                                        "description": "Check if value are equal.",
                                                        "type": "string"
                                                    },
                                                    "=": {
                                                        "description": "Check if value are equal.",
                                                        "type": "string"
                                                    },
                                                    "lengthMin": {
                                                        "description": "Check the minimum string length.",
                                                        "type": "integer"
                                                    },
                                                    "lengthMax": {
                                                        "description": "Check the maximum string length.",
                                                        "type": "integer"
                                                    },
                                                    "starts": {
                                                        "description": "Check if a string contains a prefix.",
                                                        "type": "string"
                                                    },
                                                    "notStarts": {
                                                        "description": "Check if a string not contains a prefix.",
                                                        "type": "string"
                                                    },
                                                    "ends": {
                                                        "description": "Check if a string contains a suffix.",
                                                        "type": "string"
                                                    },
                                                    "notEnds": {
                                                        "description": "Check if a string not contains a suffix.",
                                                        "type": "string"
                                                    },
                                                    "contains": {
                                                        "description": "Check if a string contains a substring.",
                                                        "type": "string"
                                                    },
                                                    "notEquals": {
                                                        "description": "Check if value are not equal.",
                                                        "type": "string"
                                                    },
                                                    "!=": {
                                                        "description": "Check if value are not equal.",
                                                        "type": "string"
                                                    },
                                                    "equalsAny": {
                                                        "description": "Check if the field is equal to one of the values.",
                                                        "type": "string"
                                                    },
                                                    "match": {
                                                        "description": "Check if a string match a regex.",
                                                        "type": "string"
                                                    },
                                                    "isEmpty": {
                                                        "description": "Check if a value is empty.",
                                                        "type": "boolean"
                                                    },
                                                    "isCamelCase": {
                                                        "description": "Check if a string is camelCase.",
                                                        "type": "boolean"
                                                    },
                                                    "isStudlyCase": {
                                                        "description": "Check if a string is StudlyCase.",
                                                        "type": "boolean"
                                                    },
                                                    "isUpperCase": {
                                                        "description": "Check if a string is upper case.",
                                                        "type": "boolean"
                                                    },
                                                    "isLowerCase": {
                                                        "description": "Check if a string is lower case.",
                                                        "type": "boolean"
                                                    },
                                                    "isSnakeCase": {
                                                        "description": "Check if a string is snake_case.",
                                                        "type": "boolean"
                                                    },
                                                    "isKebabCase": {
                                                        "description": "Check if a string is kebab-case.",
                                                        "type": "boolean"
                                                    },
                                                    "linesMax": {
                                                        "description": "Check the maximum string lines.",
                                                        "type": "integer"
                                                    },
                                                    "containsLine": {
                                                        "description": "Check if a string contains a line.",
                                                        "type": "string"
                                                    },
                                                    "notStartsAny": {
                                                        "description": "Check if a string not contains a prefixes.",
                                                        "type": "string"
                                                    },
                                                    "isNumber": {
                                                        "description": "Check if value are number.",
                                                        "type": "boolean"
                                                    },
                                                    "containsNumber": {
                                                        "description": "Check if value are contains number.",
                                                        "type": "boolean"
                                                    }
                                                },
                                                "additionalProperties": false
                                            },
                                            "$any": {
                                                "description": "True if any value of array matched conditions.",
                                                "type": "object",
                                                "properties": {
                                                    "equals": {
                                                        "description": "Check if value are equal.",
                                                        "type": "string"
                                                    },
                                                    "=": {
                                                        "description": "Check if value are equal.",
                                                        "type": "string"
                                                    },
                                                    "lengthMin": {
                                                        "description": "Check the minimum string length.",
                                                        "type": "integer"
                                                    },
                                                    "lengthMax": {
                                                        "description": "Check the maximum string length.",
                                                        "type": "integer"
                                                    },
                                                    "starts": {
                                                        "description": "Check if a string contains a prefix.",
                                                        "type": "string"
                                                    },
                                                    "notStarts": {
                                                        "description": "Check if a string not contains a prefix.",
                                                        "type": "string"
                                                    },
                                                    "ends": {
                                                        "description": "Check if a string contains a suffix.",
                                                        "type": "string"
                                                    },
                                                    "notEnds": {
                                                        "description": "Check if a string not contains a suffix.",
                                                        "type": "string"
                                                    },
                                                    "contains": {
                                                        "description": "Check if a string contains a substring.",
                                                        "type": "string"
                                                    },
                                                    "notEquals": {
                                                        "description": "Check if value are not equal.",
                                                        "type": "string"
                                                    },
                                                    "!=": {
                                                        "description": "Check if value are not equal.",
                                                        "type": "string"
                                                    },
                                                    "equalsAny": {
                                                        "description": "Check if the field is equal to one of the values.",
                                                        "type": "string"
                                                    },
                                                    "match": {
                                                        "description": "Check if a string match a regex.",
                                                        "type": "string"
                                                    },
                                                    "isEmpty": {
                                                        "description": "Check if a value is empty.",
                                                        "type": "boolean"
                                                    },
                                                    "isCamelCase": {
                                                        "description": "Check if a string is camelCase.",
                                                        "type": "boolean"
                                                    },
                                                    "isStudlyCase": {
                                                        "description": "Check if a string is StudlyCase.",
                                                        "type": "boolean"
                                                    },
                                                    "isUpperCase": {
                                                        "description": "Check if a string is upper case.",
                                                        "type": "boolean"
                                                    },
                                                    "isLowerCase": {
                                                        "description": "Check if a string is lower case.",
                                                        "type": "boolean"
                                                    },
                                                    "isSnakeCase": {
                                                        "description": "Check if a string is snake_case.",
                                                        "type": "boolean"
                                                    },
                                                    "isKebabCase": {
                                                        "description": "Check if a string is kebab-case.",
                                                        "type": "boolean"
                                                    },
                                                    "linesMax": {
                                                        "description": "Check the maximum string lines.",
                                                        "type": "integer"
                                                    },
                                                    "containsLine": {
                                                        "description": "Check if a string contains a line.",
                                                        "type": "string"
                                                    },
                                                    "notStartsAny": {
                                                        "description": "Check if a string not contains a prefixes.",
                                                        "type": "string"
                                                    },
                                                    "isNumber": {
                                                        "description": "Check if value are number.",
                                                        "type": "boolean"
                                                    },
                                                    "containsNumber": {
                                                        "description": "Check if value are contains number.",
                                                        "type": "boolean"
                                                    }
                                                },
                                                "additionalProperties": false
                                            },
                                            "notIntersect": {
                                                "description": "Check that the array does not intersect with the user array.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.hasConflicts": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "boolean"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "boolean"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "boolean"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.sourceBranch": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "lengthMin": {
                                                "description": "Check the minimum string length.",
                                                "type": "integer"
                                            },
                                            "lengthMax": {
                                                "description": "Check the maximum string length.",
                                                "type": "integer"
                                            },
                                            "starts": {
                                                "description": "Check if a string contains a prefix.",
                                                "type": "string"
                                            },
                                            "notStarts": {
                                                "description": "Check if a string not contains a prefix.",
                                                "type": "string"
                                            },
                                            "ends": {
                                                "description": "Check if a string contains a suffix.",
                                                "type": "string"
                                            },
                                            "notEnds": {
                                                "description": "Check if a string not contains a suffix.",
                                                "type": "string"
                                            },
                                            "contains": {
                                                "description": "Check if a string contains a substring.",
                                                "type": "string"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "equalsAny": {
                                                "description": "Check if the field is equal to one of the values.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "match": {
                                                "description": "Check if a string match a regex.",
                                                "type": "string"
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "isCamelCase": {
                                                "description": "Check if a string is camelCase.",
                                                "type": "boolean"
                                            },
                                            "isStudlyCase": {
                                                "description": "Check if a string is StudlyCase.",
                                                "type": "boolean"
                                            },
                                            "isUpperCase": {
                                                "description": "Check if a string is upper case.",
                                                "type": "boolean"
                                            },
                                            "isLowerCase": {
                                                "description": "Check if a string is lower case.",
                                                "type": "boolean"
                                            },
                                            "isSnakeCase": {
                                                "description": "Check if a string is snake_case.",
                                                "type": "boolean"
                                            },
                                            "isKebabCase": {
                                                "description": "Check if a string is kebab-case.",
                                                "type": "boolean"
                                            },
                                            "linesMax": {
                                                "description": "Check the maximum string lines.",
                                                "type": "integer"
                                            },
                                            "containsLine": {
                                                "description": "Check if a string contains a line.",
                                                "type": "string"
                                            },
                                            "notStartsAny": {
                                                "description": "Check if a string not contains a prefixes.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isNumber": {
                                                "description": "Check if value are number.",
                                                "type": "boolean"
                                            },
                                            "containsNumber": {
                                                "description": "Check if value are contains number.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.targetBranch": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "lengthMin": {
                                                "description": "Check the minimum string length.",
                                                "type": "integer"
                                            },
                                            "lengthMax": {
                                                "description": "Check the maximum string length.",
                                                "type": "integer"
                                            },
                                            "starts": {
                                                "description": "Check if a string contains a prefix.",
                                                "type": "string"
                                            },
                                            "notStarts": {
                                                "description": "Check if a string not contains a prefix.",
                                                "type": "string"
                                            },
                                            "ends": {
                                                "description": "Check if a string contains a suffix.",
                                                "type": "string"
                                            },
                                            "notEnds": {
                                                "description": "Check if a string not contains a suffix.",
                                                "type": "string"
                                            },
                                            "contains": {
                                                "description": "Check if a string contains a substring.",
                                                "type": "string"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "equalsAny": {
                                                "description": "Check if the field is equal to one of the values.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "match": {
                                                "description": "Check if a string match a regex.",
                                                "type": "string"
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "isCamelCase": {
                                                "description": "Check if a string is camelCase.",
                                                "type": "boolean"
                                            },
                                            "isStudlyCase": {
                                                "description": "Check if a string is StudlyCase.",
                                                "type": "boolean"
                                            },
                                            "isUpperCase": {
                                                "description": "Check if a string is upper case.",
                                                "type": "boolean"
                                            },
                                            "isLowerCase": {
                                                "description": "Check if a string is lower case.",
                                                "type": "boolean"
                                            },
                                            "isSnakeCase": {
                                                "description": "Check if a string is snake_case.",
                                                "type": "boolean"
                                            },
                                            "isKebabCase": {
                                                "description": "Check if a string is kebab-case.",
                                                "type": "boolean"
                                            },
                                            "linesMax": {
                                                "description": "Check the maximum string lines.",
                                                "type": "integer"
                                            },
                                            "containsLine": {
                                                "description": "Check if a string contains a line.",
                                                "type": "string"
                                            },
                                            "notStartsAny": {
                                                "description": "Check if a string not contains a prefixes.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isNumber": {
                                                "description": "Check if value are number.",
                                                "type": "boolean"
                                            },
                                            "containsNumber": {
                                                "description": "Check if value are contains number.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.author.login": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "lengthMin": {
                                                "description": "Check the minimum string length.",
                                                "type": "integer"
                                            },
                                            "lengthMax": {
                                                "description": "Check the maximum string length.",
                                                "type": "integer"
                                            },
                                            "starts": {
                                                "description": "Check if a string contains a prefix.",
                                                "type": "string"
                                            },
                                            "notStarts": {
                                                "description": "Check if a string not contains a prefix.",
                                                "type": "string"
                                            },
                                            "ends": {
                                                "description": "Check if a string contains a suffix.",
                                                "type": "string"
                                            },
                                            "notEnds": {
                                                "description": "Check if a string not contains a suffix.",
                                                "type": "string"
                                            },
                                            "contains": {
                                                "description": "Check if a string contains a substring.",
                                                "type": "string"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "equalsAny": {
                                                "description": "Check if the field is equal to one of the values.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "match": {
                                                "description": "Check if a string match a regex.",
                                                "type": "string"
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "isCamelCase": {
                                                "description": "Check if a string is camelCase.",
                                                "type": "boolean"
                                            },
                                            "isStudlyCase": {
                                                "description": "Check if a string is StudlyCase.",
                                                "type": "boolean"
                                            },
                                            "isUpperCase": {
                                                "description": "Check if a string is upper case.",
                                                "type": "boolean"
                                            },
                                            "isLowerCase": {
                                                "description": "Check if a string is lower case.",
                                                "type": "boolean"
                                            },
                                            "isSnakeCase": {
                                                "description": "Check if a string is snake_case.",
                                                "type": "boolean"
                                            },
                                            "isKebabCase": {
                                                "description": "Check if a string is kebab-case.",
                                                "type": "boolean"
                                            },
                                            "linesMax": {
                                                "description": "Check the maximum string lines.",
                                                "type": "integer"
                                            },
                                            "containsLine": {
                                                "description": "Check if a string contains a line.",
                                                "type": "string"
                                            },
                                            "notStartsAny": {
                                                "description": "Check if a string not contains a prefixes.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isNumber": {
                                                "description": "Check if value are number.",
                                                "type": "boolean"
                                            },
                                            "containsNumber": {
                                                "description": "Check if value are contains number.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.isDraft": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "boolean"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "boolean"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "boolean"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.canMerge": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "boolean"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "boolean"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "boolean"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.changes": {
                                        "type": "object",
                                        "properties": {
                                            "countMin": {
                                                "description": "Check the minimum number of elements in a field.",
                                                "type": "integer"
                                            },
                                            "countMax": {
                                                "description": "Check the maximum number of elements in a field.",
                                                "type": "integer"
                                            },
                                            "countEquals": {
                                                "description": "Check count equals.",
                                                "type": "integer"
                                            },
                                            "countNotEquals": {
                                                "description": "Check count not equals.",
                                                "type": "integer"
                                            },
                                            "countEqualsAny": {
                                                "description": "Check count equals.",
                                                "type": "array",
                                                "items": {
                                                    "type": "integer"
                                                }
                                            },
                                            "has": {
                                                "description": "Check if an array contains some value.",
                                                "type": "object"
                                            },
                                            "notHas": {
                                                "description": "Check if an array not contains some value.",
                                                "type": "object"
                                            },
                                            "hasAny": {
                                                "description": "Check if an array contains some value of list.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "notHasAny": {
                                                "description": "Check if an array not contains values of list.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "notIntersect": {
                                                "description": "Check that the array does not intersect with the user array.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.uri": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "lengthMin": {
                                                "description": "Check the minimum string length.",
                                                "type": "integer"
                                            },
                                            "lengthMax": {
                                                "description": "Check the maximum string length.",
                                                "type": "integer"
                                            },
                                            "starts": {
                                                "description": "Check if a string contains a prefix.",
                                                "type": "string"
                                            },
                                            "notStarts": {
                                                "description": "Check if a string not contains a prefix.",
                                                "type": "string"
                                            },
                                            "ends": {
                                                "description": "Check if a string contains a suffix.",
                                                "type": "string"
                                            },
                                            "notEnds": {
                                                "description": "Check if a string not contains a suffix.",
                                                "type": "string"
                                            },
                                            "contains": {
                                                "description": "Check if a string contains a substring.",
                                                "type": "string"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "equalsAny": {
                                                "description": "Check if the field is equal to one of the values.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "match": {
                                                "description": "Check if a string match a regex.",
                                                "type": "string"
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "isCamelCase": {
                                                "description": "Check if a string is camelCase.",
                                                "type": "boolean"
                                            },
                                            "isStudlyCase": {
                                                "description": "Check if a string is StudlyCase.",
                                                "type": "boolean"
                                            },
                                            "isUpperCase": {
                                                "description": "Check if a string is upper case.",
                                                "type": "boolean"
                                            },
                                            "isLowerCase": {
                                                "description": "Check if a string is lower case.",
                                                "type": "boolean"
                                            },
                                            "isSnakeCase": {
                                                "description": "Check if a string is snake_case.",
                                                "type": "boolean"
                                            },
                                            "isKebabCase": {
                                                "description": "Check if a string is kebab-case.",
                                                "type": "boolean"
                                            },
                                            "linesMax": {
                                                "description": "Check the maximum string lines.",
                                                "type": "integer"
                                            },
                                            "containsLine": {
                                                "description": "Check if a string contains a line.",
                                                "type": "string"
                                            },
                                            "notStartsAny": {
                                                "description": "Check if a string not contains a prefixes.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isNumber": {
                                                "description": "Check if value are number.",
                                                "type": "boolean"
                                            },
                                            "containsNumber": {
                                                "description": "Check if value are contains number.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.id": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "lengthMin": {
                                                "description": "Check the minimum string length.",
                                                "type": "integer"
                                            },
                                            "lengthMax": {
                                                "description": "Check the maximum string length.",
                                                "type": "integer"
                                            },
                                            "starts": {
                                                "description": "Check if a string contains a prefix.",
                                                "type": "string"
                                            },
                                            "notStarts": {
                                                "description": "Check if a string not contains a prefix.",
                                                "type": "string"
                                            },
                                            "ends": {
                                                "description": "Check if a string contains a suffix.",
                                                "type": "string"
                                            },
                                            "notEnds": {
                                                "description": "Check if a string not contains a suffix.",
                                                "type": "string"
                                            },
                                            "contains": {
                                                "description": "Check if a string contains a substring.",
                                                "type": "string"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "equalsAny": {
                                                "description": "Check if the field is equal to one of the values.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "match": {
                                                "description": "Check if a string match a regex.",
                                                "type": "string"
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "isCamelCase": {
                                                "description": "Check if a string is camelCase.",
                                                "type": "boolean"
                                            },
                                            "isStudlyCase": {
                                                "description": "Check if a string is StudlyCase.",
                                                "type": "boolean"
                                            },
                                            "isUpperCase": {
                                                "description": "Check if a string is upper case.",
                                                "type": "boolean"
                                            },
                                            "isLowerCase": {
                                                "description": "Check if a string is lower case.",
                                                "type": "boolean"
                                            },
                                            "isSnakeCase": {
                                                "description": "Check if a string is snake_case.",
                                                "type": "boolean"
                                            },
                                            "isKebabCase": {
                                                "description": "Check if a string is kebab-case.",
                                                "type": "boolean"
                                            },
                                            "linesMax": {
                                                "description": "Check the maximum string lines.",
                                                "type": "integer"
                                            },
                                            "containsLine": {
                                                "description": "Check if a string contains a line.",
                                                "type": "string"
                                            },
                                            "notStartsAny": {
                                                "description": "Check if a string not contains a prefixes.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isNumber": {
                                                "description": "Check if value are number.",
                                                "type": "boolean"
                                            },
                                            "containsNumber": {
                                                "description": "Check if value are contains number.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "request.number": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "lengthMin": {
                                                "description": "Check the minimum string length.",
                                                "type": "integer"
                                            },
                                            "lengthMax": {
                                                "description": "Check the maximum string length.",
                                                "type": "integer"
                                            },
                                            "starts": {
                                                "description": "Check if a string contains a prefix.",
                                                "type": "string"
                                            },
                                            "notStarts": {
                                                "description": "Check if a string not contains a prefix.",
                                                "type": "string"
                                            },
                                            "ends": {
                                                "description": "Check if a string contains a suffix.",
                                                "type": "string"
                                            },
                                            "notEnds": {
                                                "description": "Check if a string not contains a suffix.",
                                                "type": "string"
                                            },
                                            "contains": {
                                                "description": "Check if a string contains a substring.",
                                                "type": "string"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "equalsAny": {
                                                "description": "Check if the field is equal to one of the values.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "match": {
                                                "description": "Check if a string match a regex.",
                                                "type": "string"
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "isCamelCase": {
                                                "description": "Check if a string is camelCase.",
                                                "type": "boolean"
                                            },
                                            "isStudlyCase": {
                                                "description": "Check if a string is StudlyCase.",
                                                "type": "boolean"
                                            },
                                            "isUpperCase": {
                                                "description": "Check if a string is upper case.",
                                                "type": "boolean"
                                            },
                                            "isLowerCase": {
                                                "description": "Check if a string is lower case.",
                                                "type": "boolean"
                                            },
                                            "isSnakeCase": {
                                                "description": "Check if a string is snake_case.",
                                                "type": "boolean"
                                            },
                                            "isKebabCase": {
                                                "description": "Check if a string is kebab-case.",
                                                "type": "boolean"
                                            },
                                            "linesMax": {
                                                "description": "Check the maximum string lines.",
                                                "type": "integer"
                                            },
                                            "containsLine": {
                                                "description": "Check if a string contains a line.",
                                                "type": "string"
                                            },
                                            "notStartsAny": {
                                                "description": "Check if a string not contains a prefixes.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isNumber": {
                                                "description": "Check if value are number.",
                                                "type": "boolean"
                                            },
                                            "containsNumber": {
                                                "description": "Check if value are contains number.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "result.state.name": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "string"
                                            },
                                            "lengthMin": {
                                                "description": "Check the minimum string length.",
                                                "type": "integer"
                                            },
                                            "lengthMax": {
                                                "description": "Check the maximum string length.",
                                                "type": "integer"
                                            },
                                            "starts": {
                                                "description": "Check if a string contains a prefix.",
                                                "type": "string"
                                            },
                                            "notStarts": {
                                                "description": "Check if a string not contains a prefix.",
                                                "type": "string"
                                            },
                                            "ends": {
                                                "description": "Check if a string contains a suffix.",
                                                "type": "string"
                                            },
                                            "notEnds": {
                                                "description": "Check if a string not contains a suffix.",
                                                "type": "string"
                                            },
                                            "contains": {
                                                "description": "Check if a string contains a substring.",
                                                "type": "string"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "string"
                                            },
                                            "equalsAny": {
                                                "description": "Check if the field is equal to one of the values.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "match": {
                                                "description": "Check if a string match a regex.",
                                                "type": "string"
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "isCamelCase": {
                                                "description": "Check if a string is camelCase.",
                                                "type": "boolean"
                                            },
                                            "isStudlyCase": {
                                                "description": "Check if a string is StudlyCase.",
                                                "type": "boolean"
                                            },
                                            "isUpperCase": {
                                                "description": "Check if a string is upper case.",
                                                "type": "boolean"
                                            },
                                            "isLowerCase": {
                                                "description": "Check if a string is lower case.",
                                                "type": "boolean"
                                            },
                                            "isSnakeCase": {
                                                "description": "Check if a string is snake_case.",
                                                "type": "boolean"
                                            },
                                            "isKebabCase": {
                                                "description": "Check if a string is kebab-case.",
                                                "type": "boolean"
                                            },
                                            "linesMax": {
                                                "description": "Check the maximum string lines.",
                                                "type": "integer"
                                            },
                                            "containsLine": {
                                                "description": "Check if a string contains a line.",
                                                "type": "string"
                                            },
                                            "notStartsAny": {
                                                "description": "Check if a string not contains a prefixes.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isNumber": {
                                                "description": "Check if value are number.",
                                                "type": "boolean"
                                            },
                                            "containsNumber": {
                                                "description": "Check if value are contains number.",
                                                "type": "boolean"
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "result.state.value": {
                                        "type": "object",
                                        "properties": [],
                                        "additionalProperties": false
                                    },
                                    "result.notes": {
                                        "type": "object",
                                        "properties": {
                                            "countMin": {
                                                "description": "Check the minimum number of elements in a field.",
                                                "type": "integer"
                                            },
                                            "countMax": {
                                                "description": "Check the maximum number of elements in a field.",
                                                "type": "integer"
                                            },
                                            "countEquals": {
                                                "description": "Check count equals.",
                                                "type": "integer"
                                            },
                                            "countNotEquals": {
                                                "description": "Check count not equals.",
                                                "type": "integer"
                                            },
                                            "countEqualsAny": {
                                                "description": "Check count equals.",
                                                "type": "array",
                                                "items": {
                                                    "type": "integer"
                                                }
                                            },
                                            "notHasAny": {
                                                "description": "Check if an array not contains values of list.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "hasAny": {
                                                "description": "Check if an array contains some value of list.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            },
                                            "isEmpty": {
                                                "description": "Check if a value is empty.",
                                                "type": "boolean"
                                            },
                                            "notIntersect": {
                                                "description": "Check that the array does not intersect with the user array.",
                                                "type": "array",
                                                "items": {
                                                    "type": "string"
                                                }
                                            }
                                        },
                                        "additionalProperties": false
                                    },
                                    "result.duration.seconds": {
                                        "type": "object",
                                        "properties": {
                                            "equals": {
                                                "description": "Check if value are equal.",
                                                "type": "number"
                                            },
                                            "=": {
                                                "description": "Check if value are equal.",
                                                "type": "number"
                                            },
                                            "notEquals": {
                                                "description": "Check if value are not equal.",
                                                "type": "number"
                                            },
                                            "!=": {
                                                "description": "Check if value are not equal.",
                                                "type": "number"
                                            },
                                            "lte": {
                                                "description": "Check number is equal to or less than.",
                                                "type": "number"
                                            },
                                            "<=": {
                                                "description": "Check number is equal to or less than.",
                                                "type": "number"
                                            },
                                            "gte": {
                                                "description": "Check if a number is greater than or less than.",
                                                "type": "number"
                                            },
                                            ">=": {
                                                "description": "Check if a number is greater than or less than.",
                                                "type": "number"
                                            }
                                        },
                                        "additionalProperties": false
                                    }
                                },
                                "additionalProperties": false
                            }
                        }
                    }
                }
            }
        },
        "ci": {
            "type": "object",
            "properties": {
                "gitlab_ci": {
                    "description": "Gitlab CI settings",
                    "type": "object",
                    "properties": {
                        "credentials": {
                            "type": "object",
                            "properties": {
                                "token": {
                                    "type": "string",
                                    "description": "Access Token"
                                },
                                "job_token": {
                                    "type": "string",
                                    "description": "Job Token"
                                }
                            }
                        }
                    }
                },
                "github_actions": {
                    "description": "Github Actions settings",
                    "type": "object",
                    "properties": {
                        "credentials": {
                            "type": "object",
                            "properties": {
                                "token": {
                                    "type": "string",
                                    "description": "API Token"
                                }
                            }
                        }
                    }
                },
                "bitbucket_pipelines": {
                    "description": "Bitbucket Pipelines settings",
                    "type": "object",
                    "properties": {
                        "credentials": {
                            "type": "object",
                            "properties": {
                                "app_password": {
                                    "type": "object",
                                    "properties": {
                                        "user": {
                                            "type": "string"
                                        },
                                        "password": {
                                            "type": "string"
                                        }
                                    }
                                },
                                "host": {
                                    "type": "string",
                                    "description": "API Host"
                                }
                            }
                        },
                        "labels": {
                            "type": "object",
                            "properties": {
                                "of_description": {
                                    "type": "object",
                                    "properties": {
                                        "line_starts_with": {
                                            "type": "string",
                                            "description": "Line Prefix"
                                        },
                                        "separator": {
                                            "type": "string",
                                            "description": "Labels separator"
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            },
            "additionalProperties": false
        },
        "notifications": {
            "type": "object",
            "properties": {
                "channels": {
                    "type": "object",
                    "additionalProperties": {
                        "$ref": "#/definitions/notifications_channel"
                    }
                },
                "on": {
                    "type": "object",
                    "properties": {
                        "lint_started": {
                            "type": "object",
                            "properties": {
                                "template": {
                                    "type": "string"
                                },
                                "channel": {
                                    "type": "string"
                                },
                                "when": {
                                    "properties": {
                                        "request.title": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.descriptionMarkdown": {
                                            "type": "object",
                                            "properties": {
                                                "containsHeading1": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                },
                                                "containsHeading2": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                },
                                                "containsHeading3": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                },
                                                "containsHeading4": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                },
                                                "containsHeading5": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                },
                                                "containsHeading6": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.description": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.labels": {
                                            "type": "object",
                                            "properties": {
                                                "countMin": {
                                                    "description": "Check the minimum number of elements in a field.",
                                                    "type": "integer"
                                                },
                                                "countMax": {
                                                    "description": "Check the maximum number of elements in a field.",
                                                    "type": "integer"
                                                },
                                                "countEquals": {
                                                    "description": "Check count equals.",
                                                    "type": "integer"
                                                },
                                                "countNotEquals": {
                                                    "description": "Check count not equals.",
                                                    "type": "integer"
                                                },
                                                "countEqualsAny": {
                                                    "description": "Check count equals.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "integer"
                                                    }
                                                },
                                                "has": {
                                                    "description": "Check if an array contains some value.",
                                                    "type": "string"
                                                },
                                                "notHas": {
                                                    "description": "Check if an array not contains some value.",
                                                    "type": "string"
                                                },
                                                "hasAny": {
                                                    "description": "Check if an array contains some value of list.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "notHasAny": {
                                                    "description": "Check if an array not contains values of list.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "$all": {
                                                    "description": "True if all values of array matched conditions.",
                                                    "type": "object",
                                                    "properties": {
                                                        "equals": {
                                                            "description": "Check if value are equal.",
                                                            "type": "string"
                                                        },
                                                        "=": {
                                                            "description": "Check if value are equal.",
                                                            "type": "string"
                                                        },
                                                        "lengthMin": {
                                                            "description": "Check the minimum string length.",
                                                            "type": "integer"
                                                        },
                                                        "lengthMax": {
                                                            "description": "Check the maximum string length.",
                                                            "type": "integer"
                                                        },
                                                        "starts": {
                                                            "description": "Check if a string contains a prefix.",
                                                            "type": "string"
                                                        },
                                                        "notStarts": {
                                                            "description": "Check if a string not contains a prefix.",
                                                            "type": "string"
                                                        },
                                                        "ends": {
                                                            "description": "Check if a string contains a suffix.",
                                                            "type": "string"
                                                        },
                                                        "notEnds": {
                                                            "description": "Check if a string not contains a suffix.",
                                                            "type": "string"
                                                        },
                                                        "contains": {
                                                            "description": "Check if a string contains a substring.",
                                                            "type": "string"
                                                        },
                                                        "notEquals": {
                                                            "description": "Check if value are not equal.",
                                                            "type": "string"
                                                        },
                                                        "!=": {
                                                            "description": "Check if value are not equal.",
                                                            "type": "string"
                                                        },
                                                        "equalsAny": {
                                                            "description": "Check if the field is equal to one of the values.",
                                                            "type": "string"
                                                        },
                                                        "match": {
                                                            "description": "Check if a string match a regex.",
                                                            "type": "string"
                                                        },
                                                        "isEmpty": {
                                                            "description": "Check if a value is empty.",
                                                            "type": "boolean"
                                                        },
                                                        "isCamelCase": {
                                                            "description": "Check if a string is camelCase.",
                                                            "type": "boolean"
                                                        },
                                                        "isStudlyCase": {
                                                            "description": "Check if a string is StudlyCase.",
                                                            "type": "boolean"
                                                        },
                                                        "isUpperCase": {
                                                            "description": "Check if a string is upper case.",
                                                            "type": "boolean"
                                                        },
                                                        "isLowerCase": {
                                                            "description": "Check if a string is lower case.",
                                                            "type": "boolean"
                                                        },
                                                        "isSnakeCase": {
                                                            "description": "Check if a string is snake_case.",
                                                            "type": "boolean"
                                                        },
                                                        "isKebabCase": {
                                                            "description": "Check if a string is kebab-case.",
                                                            "type": "boolean"
                                                        },
                                                        "linesMax": {
                                                            "description": "Check the maximum string lines.",
                                                            "type": "integer"
                                                        },
                                                        "containsLine": {
                                                            "description": "Check if a string contains a line.",
                                                            "type": "string"
                                                        },
                                                        "notStartsAny": {
                                                            "description": "Check if a string not contains a prefixes.",
                                                            "type": "string"
                                                        },
                                                        "isNumber": {
                                                            "description": "Check if value are number.",
                                                            "type": "boolean"
                                                        },
                                                        "containsNumber": {
                                                            "description": "Check if value are contains number.",
                                                            "type": "boolean"
                                                        }
                                                    },
                                                    "additionalProperties": false
                                                },
                                                "$any": {
                                                    "description": "True if any value of array matched conditions.",
                                                    "type": "object",
                                                    "properties": {
                                                        "equals": {
                                                            "description": "Check if value are equal.",
                                                            "type": "string"
                                                        },
                                                        "=": {
                                                            "description": "Check if value are equal.",
                                                            "type": "string"
                                                        },
                                                        "lengthMin": {
                                                            "description": "Check the minimum string length.",
                                                            "type": "integer"
                                                        },
                                                        "lengthMax": {
                                                            "description": "Check the maximum string length.",
                                                            "type": "integer"
                                                        },
                                                        "starts": {
                                                            "description": "Check if a string contains a prefix.",
                                                            "type": "string"
                                                        },
                                                        "notStarts": {
                                                            "description": "Check if a string not contains a prefix.",
                                                            "type": "string"
                                                        },
                                                        "ends": {
                                                            "description": "Check if a string contains a suffix.",
                                                            "type": "string"
                                                        },
                                                        "notEnds": {
                                                            "description": "Check if a string not contains a suffix.",
                                                            "type": "string"
                                                        },
                                                        "contains": {
                                                            "description": "Check if a string contains a substring.",
                                                            "type": "string"
                                                        },
                                                        "notEquals": {
                                                            "description": "Check if value are not equal.",
                                                            "type": "string"
                                                        },
                                                        "!=": {
                                                            "description": "Check if value are not equal.",
                                                            "type": "string"
                                                        },
                                                        "equalsAny": {
                                                            "description": "Check if the field is equal to one of the values.",
                                                            "type": "string"
                                                        },
                                                        "match": {
                                                            "description": "Check if a string match a regex.",
                                                            "type": "string"
                                                        },
                                                        "isEmpty": {
                                                            "description": "Check if a value is empty.",
                                                            "type": "boolean"
                                                        },
                                                        "isCamelCase": {
                                                            "description": "Check if a string is camelCase.",
                                                            "type": "boolean"
                                                        },
                                                        "isStudlyCase": {
                                                            "description": "Check if a string is StudlyCase.",
                                                            "type": "boolean"
                                                        },
                                                        "isUpperCase": {
                                                            "description": "Check if a string is upper case.",
                                                            "type": "boolean"
                                                        },
                                                        "isLowerCase": {
                                                            "description": "Check if a string is lower case.",
                                                            "type": "boolean"
                                                        },
                                                        "isSnakeCase": {
                                                            "description": "Check if a string is snake_case.",
                                                            "type": "boolean"
                                                        },
                                                        "isKebabCase": {
                                                            "description": "Check if a string is kebab-case.",
                                                            "type": "boolean"
                                                        },
                                                        "linesMax": {
                                                            "description": "Check the maximum string lines.",
                                                            "type": "integer"
                                                        },
                                                        "containsLine": {
                                                            "description": "Check if a string contains a line.",
                                                            "type": "string"
                                                        },
                                                        "notStartsAny": {
                                                            "description": "Check if a string not contains a prefixes.",
                                                            "type": "string"
                                                        },
                                                        "isNumber": {
                                                            "description": "Check if value are number.",
                                                            "type": "boolean"
                                                        },
                                                        "containsNumber": {
                                                            "description": "Check if value are contains number.",
                                                            "type": "boolean"
                                                        }
                                                    },
                                                    "additionalProperties": false
                                                },
                                                "notIntersect": {
                                                    "description": "Check that the array does not intersect with the user array.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.hasConflicts": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.sourceBranch": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.targetBranch": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.author.login": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.isDraft": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.canMerge": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.changes": {
                                            "type": "object",
                                            "properties": {
                                                "countMin": {
                                                    "description": "Check the minimum number of elements in a field.",
                                                    "type": "integer"
                                                },
                                                "countMax": {
                                                    "description": "Check the maximum number of elements in a field.",
                                                    "type": "integer"
                                                },
                                                "countEquals": {
                                                    "description": "Check count equals.",
                                                    "type": "integer"
                                                },
                                                "countNotEquals": {
                                                    "description": "Check count not equals.",
                                                    "type": "integer"
                                                },
                                                "countEqualsAny": {
                                                    "description": "Check count equals.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "integer"
                                                    }
                                                },
                                                "has": {
                                                    "description": "Check if an array contains some value.",
                                                    "type": "object"
                                                },
                                                "notHas": {
                                                    "description": "Check if an array not contains some value.",
                                                    "type": "object"
                                                },
                                                "hasAny": {
                                                    "description": "Check if an array contains some value of list.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "notHasAny": {
                                                    "description": "Check if an array not contains values of list.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "notIntersect": {
                                                    "description": "Check that the array does not intersect with the user array.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.uri": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.id": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.number": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        }
                                    },
                                    "additionalProperties": false
                                }
                            },
                            "description": "The event is created at the moment when the linter has just started."
                        },
                        "rule_was_failed": {
                            "type": "object",
                            "properties": {
                                "template": {
                                    "type": "string"
                                },
                                "channel": {
                                    "type": "string"
                                },
                                "when": {
                                    "properties": {
                                        "ruleName": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "notes": {
                                            "type": "object",
                                            "properties": [],
                                            "additionalProperties": false
                                        }
                                    },
                                    "additionalProperties": false
                                }
                            },
                            "description": "The event is created at the moment when the linter rule was failed."
                        },
                        "lint_finished": {
                            "type": "object",
                            "properties": {
                                "template": {
                                    "type": "string"
                                },
                                "channel": {
                                    "type": "string"
                                },
                                "when": {
                                    "properties": {
                                        "request.title": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.descriptionMarkdown": {
                                            "type": "object",
                                            "properties": {
                                                "containsHeading1": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                },
                                                "containsHeading2": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                },
                                                "containsHeading3": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                },
                                                "containsHeading4": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                },
                                                "containsHeading5": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                },
                                                "containsHeading6": {
                                                    "description": "Check if a markdown-string contains a heading.",
                                                    "type": "string"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.description": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.labels": {
                                            "type": "object",
                                            "properties": {
                                                "countMin": {
                                                    "description": "Check the minimum number of elements in a field.",
                                                    "type": "integer"
                                                },
                                                "countMax": {
                                                    "description": "Check the maximum number of elements in a field.",
                                                    "type": "integer"
                                                },
                                                "countEquals": {
                                                    "description": "Check count equals.",
                                                    "type": "integer"
                                                },
                                                "countNotEquals": {
                                                    "description": "Check count not equals.",
                                                    "type": "integer"
                                                },
                                                "countEqualsAny": {
                                                    "description": "Check count equals.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "integer"
                                                    }
                                                },
                                                "has": {
                                                    "description": "Check if an array contains some value.",
                                                    "type": "string"
                                                },
                                                "notHas": {
                                                    "description": "Check if an array not contains some value.",
                                                    "type": "string"
                                                },
                                                "hasAny": {
                                                    "description": "Check if an array contains some value of list.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "notHasAny": {
                                                    "description": "Check if an array not contains values of list.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "$all": {
                                                    "description": "True if all values of array matched conditions.",
                                                    "type": "object",
                                                    "properties": {
                                                        "equals": {
                                                            "description": "Check if value are equal.",
                                                            "type": "string"
                                                        },
                                                        "=": {
                                                            "description": "Check if value are equal.",
                                                            "type": "string"
                                                        },
                                                        "lengthMin": {
                                                            "description": "Check the minimum string length.",
                                                            "type": "integer"
                                                        },
                                                        "lengthMax": {
                                                            "description": "Check the maximum string length.",
                                                            "type": "integer"
                                                        },
                                                        "starts": {
                                                            "description": "Check if a string contains a prefix.",
                                                            "type": "string"
                                                        },
                                                        "notStarts": {
                                                            "description": "Check if a string not contains a prefix.",
                                                            "type": "string"
                                                        },
                                                        "ends": {
                                                            "description": "Check if a string contains a suffix.",
                                                            "type": "string"
                                                        },
                                                        "notEnds": {
                                                            "description": "Check if a string not contains a suffix.",
                                                            "type": "string"
                                                        },
                                                        "contains": {
                                                            "description": "Check if a string contains a substring.",
                                                            "type": "string"
                                                        },
                                                        "notEquals": {
                                                            "description": "Check if value are not equal.",
                                                            "type": "string"
                                                        },
                                                        "!=": {
                                                            "description": "Check if value are not equal.",
                                                            "type": "string"
                                                        },
                                                        "equalsAny": {
                                                            "description": "Check if the field is equal to one of the values.",
                                                            "type": "string"
                                                        },
                                                        "match": {
                                                            "description": "Check if a string match a regex.",
                                                            "type": "string"
                                                        },
                                                        "isEmpty": {
                                                            "description": "Check if a value is empty.",
                                                            "type": "boolean"
                                                        },
                                                        "isCamelCase": {
                                                            "description": "Check if a string is camelCase.",
                                                            "type": "boolean"
                                                        },
                                                        "isStudlyCase": {
                                                            "description": "Check if a string is StudlyCase.",
                                                            "type": "boolean"
                                                        },
                                                        "isUpperCase": {
                                                            "description": "Check if a string is upper case.",
                                                            "type": "boolean"
                                                        },
                                                        "isLowerCase": {
                                                            "description": "Check if a string is lower case.",
                                                            "type": "boolean"
                                                        },
                                                        "isSnakeCase": {
                                                            "description": "Check if a string is snake_case.",
                                                            "type": "boolean"
                                                        },
                                                        "isKebabCase": {
                                                            "description": "Check if a string is kebab-case.",
                                                            "type": "boolean"
                                                        },
                                                        "linesMax": {
                                                            "description": "Check the maximum string lines.",
                                                            "type": "integer"
                                                        },
                                                        "containsLine": {
                                                            "description": "Check if a string contains a line.",
                                                            "type": "string"
                                                        },
                                                        "notStartsAny": {
                                                            "description": "Check if a string not contains a prefixes.",
                                                            "type": "string"
                                                        },
                                                        "isNumber": {
                                                            "description": "Check if value are number.",
                                                            "type": "boolean"
                                                        },
                                                        "containsNumber": {
                                                            "description": "Check if value are contains number.",
                                                            "type": "boolean"
                                                        }
                                                    },
                                                    "additionalProperties": false
                                                },
                                                "$any": {
                                                    "description": "True if any value of array matched conditions.",
                                                    "type": "object",
                                                    "properties": {
                                                        "equals": {
                                                            "description": "Check if value are equal.",
                                                            "type": "string"
                                                        },
                                                        "=": {
                                                            "description": "Check if value are equal.",
                                                            "type": "string"
                                                        },
                                                        "lengthMin": {
                                                            "description": "Check the minimum string length.",
                                                            "type": "integer"
                                                        },
                                                        "lengthMax": {
                                                            "description": "Check the maximum string length.",
                                                            "type": "integer"
                                                        },
                                                        "starts": {
                                                            "description": "Check if a string contains a prefix.",
                                                            "type": "string"
                                                        },
                                                        "notStarts": {
                                                            "description": "Check if a string not contains a prefix.",
                                                            "type": "string"
                                                        },
                                                        "ends": {
                                                            "description": "Check if a string contains a suffix.",
                                                            "type": "string"
                                                        },
                                                        "notEnds": {
                                                            "description": "Check if a string not contains a suffix.",
                                                            "type": "string"
                                                        },
                                                        "contains": {
                                                            "description": "Check if a string contains a substring.",
                                                            "type": "string"
                                                        },
                                                        "notEquals": {
                                                            "description": "Check if value are not equal.",
                                                            "type": "string"
                                                        },
                                                        "!=": {
                                                            "description": "Check if value are not equal.",
                                                            "type": "string"
                                                        },
                                                        "equalsAny": {
                                                            "description": "Check if the field is equal to one of the values.",
                                                            "type": "string"
                                                        },
                                                        "match": {
                                                            "description": "Check if a string match a regex.",
                                                            "type": "string"
                                                        },
                                                        "isEmpty": {
                                                            "description": "Check if a value is empty.",
                                                            "type": "boolean"
                                                        },
                                                        "isCamelCase": {
                                                            "description": "Check if a string is camelCase.",
                                                            "type": "boolean"
                                                        },
                                                        "isStudlyCase": {
                                                            "description": "Check if a string is StudlyCase.",
                                                            "type": "boolean"
                                                        },
                                                        "isUpperCase": {
                                                            "description": "Check if a string is upper case.",
                                                            "type": "boolean"
                                                        },
                                                        "isLowerCase": {
                                                            "description": "Check if a string is lower case.",
                                                            "type": "boolean"
                                                        },
                                                        "isSnakeCase": {
                                                            "description": "Check if a string is snake_case.",
                                                            "type": "boolean"
                                                        },
                                                        "isKebabCase": {
                                                            "description": "Check if a string is kebab-case.",
                                                            "type": "boolean"
                                                        },
                                                        "linesMax": {
                                                            "description": "Check the maximum string lines.",
                                                            "type": "integer"
                                                        },
                                                        "containsLine": {
                                                            "description": "Check if a string contains a line.",
                                                            "type": "string"
                                                        },
                                                        "notStartsAny": {
                                                            "description": "Check if a string not contains a prefixes.",
                                                            "type": "string"
                                                        },
                                                        "isNumber": {
                                                            "description": "Check if value are number.",
                                                            "type": "boolean"
                                                        },
                                                        "containsNumber": {
                                                            "description": "Check if value are contains number.",
                                                            "type": "boolean"
                                                        }
                                                    },
                                                    "additionalProperties": false
                                                },
                                                "notIntersect": {
                                                    "description": "Check that the array does not intersect with the user array.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.hasConflicts": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.sourceBranch": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.targetBranch": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.author.login": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.isDraft": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.canMerge": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "boolean"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.changes": {
                                            "type": "object",
                                            "properties": {
                                                "countMin": {
                                                    "description": "Check the minimum number of elements in a field.",
                                                    "type": "integer"
                                                },
                                                "countMax": {
                                                    "description": "Check the maximum number of elements in a field.",
                                                    "type": "integer"
                                                },
                                                "countEquals": {
                                                    "description": "Check count equals.",
                                                    "type": "integer"
                                                },
                                                "countNotEquals": {
                                                    "description": "Check count not equals.",
                                                    "type": "integer"
                                                },
                                                "countEqualsAny": {
                                                    "description": "Check count equals.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "integer"
                                                    }
                                                },
                                                "has": {
                                                    "description": "Check if an array contains some value.",
                                                    "type": "object"
                                                },
                                                "notHas": {
                                                    "description": "Check if an array not contains some value.",
                                                    "type": "object"
                                                },
                                                "hasAny": {
                                                    "description": "Check if an array contains some value of list.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "notHasAny": {
                                                    "description": "Check if an array not contains values of list.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "notIntersect": {
                                                    "description": "Check that the array does not intersect with the user array.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.uri": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.id": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "request.number": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "result.state.name": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "result.state.value": {
                                            "type": "object",
                                            "properties": [],
                                            "additionalProperties": false
                                        },
                                        "result.notes": {
                                            "type": "object",
                                            "properties": {
                                                "countMin": {
                                                    "description": "Check the minimum number of elements in a field.",
                                                    "type": "integer"
                                                },
                                                "countMax": {
                                                    "description": "Check the maximum number of elements in a field.",
                                                    "type": "integer"
                                                },
                                                "countEquals": {
                                                    "description": "Check count equals.",
                                                    "type": "integer"
                                                },
                                                "countNotEquals": {
                                                    "description": "Check count not equals.",
                                                    "type": "integer"
                                                },
                                                "countEqualsAny": {
                                                    "description": "Check count equals.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "integer"
                                                    }
                                                },
                                                "notHasAny": {
                                                    "description": "Check if an array not contains values of list.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "hasAny": {
                                                    "description": "Check if an array contains some value of list.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "notIntersect": {
                                                    "description": "Check that the array does not intersect with the user array.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                }
                                            },
                                            "additionalProperties": false
                                        },
                                        "result.duration.seconds": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "number"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "number"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "number"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "number"
                                                },
                                                "lte": {
                                                    "description": "Check number is equal to or less than.",
                                                    "type": "number"
                                                },
                                                "<=": {
                                                    "description": "Check number is equal to or less than.",
                                                    "type": "number"
                                                },
                                                "gte": {
                                                    "description": "Check if a number is greater than or less than.",
                                                    "type": "number"
                                                },
                                                ">=": {
                                                    "description": "Check if a number is greater than or less than.",
                                                    "type": "number"
                                                }
                                            },
                                            "additionalProperties": false
                                        }
                                    },
                                    "additionalProperties": false
                                }
                            },
                            "description": "The event is created at the moment when the linter has completed its work."
                        },
                        "rule_was_successful": {
                            "type": "object",
                            "properties": {
                                "template": {
                                    "type": "string"
                                },
                                "channel": {
                                    "type": "string"
                                },
                                "when": {
                                    "properties": {
                                        "ruleName": {
                                            "type": "object",
                                            "properties": {
                                                "equals": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "=": {
                                                    "description": "Check if value are equal.",
                                                    "type": "string"
                                                },
                                                "lengthMin": {
                                                    "description": "Check the minimum string length.",
                                                    "type": "integer"
                                                },
                                                "lengthMax": {
                                                    "description": "Check the maximum string length.",
                                                    "type": "integer"
                                                },
                                                "starts": {
                                                    "description": "Check if a string contains a prefix.",
                                                    "type": "string"
                                                },
                                                "notStarts": {
                                                    "description": "Check if a string not contains a prefix.",
                                                    "type": "string"
                                                },
                                                "ends": {
                                                    "description": "Check if a string contains a suffix.",
                                                    "type": "string"
                                                },
                                                "notEnds": {
                                                    "description": "Check if a string not contains a suffix.",
                                                    "type": "string"
                                                },
                                                "contains": {
                                                    "description": "Check if a string contains a substring.",
                                                    "type": "string"
                                                },
                                                "notEquals": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "!=": {
                                                    "description": "Check if value are not equal.",
                                                    "type": "string"
                                                },
                                                "equalsAny": {
                                                    "description": "Check if the field is equal to one of the values.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "match": {
                                                    "description": "Check if a string match a regex.",
                                                    "type": "string"
                                                },
                                                "isEmpty": {
                                                    "description": "Check if a value is empty.",
                                                    "type": "boolean"
                                                },
                                                "isCamelCase": {
                                                    "description": "Check if a string is camelCase.",
                                                    "type": "boolean"
                                                },
                                                "isStudlyCase": {
                                                    "description": "Check if a string is StudlyCase.",
                                                    "type": "boolean"
                                                },
                                                "isUpperCase": {
                                                    "description": "Check if a string is upper case.",
                                                    "type": "boolean"
                                                },
                                                "isLowerCase": {
                                                    "description": "Check if a string is lower case.",
                                                    "type": "boolean"
                                                },
                                                "isSnakeCase": {
                                                    "description": "Check if a string is snake_case.",
                                                    "type": "boolean"
                                                },
                                                "isKebabCase": {
                                                    "description": "Check if a string is kebab-case.",
                                                    "type": "boolean"
                                                },
                                                "linesMax": {
                                                    "description": "Check the maximum string lines.",
                                                    "type": "integer"
                                                },
                                                "containsLine": {
                                                    "description": "Check if a string contains a line.",
                                                    "type": "string"
                                                },
                                                "notStartsAny": {
                                                    "description": "Check if a string not contains a prefixes.",
                                                    "type": "array",
                                                    "items": {
                                                        "type": "string"
                                                    }
                                                },
                                                "isNumber": {
                                                    "description": "Check if value are number.",
                                                    "type": "boolean"
                                                },
                                                "containsNumber": {
                                                    "description": "Check if value are contains number.",
                                                    "type": "boolean"
                                                }
                                            },
                                            "additionalProperties": false
                                        }
                                    },
                                    "additionalProperties": false
                                }
                            },
                            "description": "The event is created at the moment when the linter rule was successful."
                        }
                    }
                }
            }
        },
        "linter": {
            "type": "object",
            "properties": {
                "options": {
                    "type": "object",
                    "properties": {
                        "stop_on_failure": {
                            "type": "boolean",
                            "default": false
                        },
                        "stop_on_warning": {
                            "type": "boolean",
                            "default": false
                        }
                    }
                }
            }
        }
    },
    "definitions": {
        "rule_conditions": {
            "properties": {
                "title": {
                    "type": "object",
                    "properties": {
                        "equals": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "=": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "lengthMin": {
                            "description": "Check the minimum string length.",
                            "type": "integer"
                        },
                        "lengthMax": {
                            "description": "Check the maximum string length.",
                            "type": "integer"
                        },
                        "starts": {
                            "description": "Check if a string contains a prefix.",
                            "type": "string"
                        },
                        "notStarts": {
                            "description": "Check if a string not contains a prefix.",
                            "type": "string"
                        },
                        "ends": {
                            "description": "Check if a string contains a suffix.",
                            "type": "string"
                        },
                        "notEnds": {
                            "description": "Check if a string not contains a suffix.",
                            "type": "string"
                        },
                        "contains": {
                            "description": "Check if a string contains a substring.",
                            "type": "string"
                        },
                        "notEquals": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "!=": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "equalsAny": {
                            "description": "Check if the field is equal to one of the values.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "match": {
                            "description": "Check if a string match a regex.",
                            "type": "string"
                        },
                        "isEmpty": {
                            "description": "Check if a value is empty.",
                            "type": "boolean"
                        },
                        "isCamelCase": {
                            "description": "Check if a string is camelCase.",
                            "type": "boolean"
                        },
                        "isStudlyCase": {
                            "description": "Check if a string is StudlyCase.",
                            "type": "boolean"
                        },
                        "isUpperCase": {
                            "description": "Check if a string is upper case.",
                            "type": "boolean"
                        },
                        "isLowerCase": {
                            "description": "Check if a string is lower case.",
                            "type": "boolean"
                        },
                        "isSnakeCase": {
                            "description": "Check if a string is snake_case.",
                            "type": "boolean"
                        },
                        "isKebabCase": {
                            "description": "Check if a string is kebab-case.",
                            "type": "boolean"
                        },
                        "linesMax": {
                            "description": "Check the maximum string lines.",
                            "type": "integer"
                        },
                        "containsLine": {
                            "description": "Check if a string contains a line.",
                            "type": "string"
                        },
                        "notStartsAny": {
                            "description": "Check if a string not contains a prefixes.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "isNumber": {
                            "description": "Check if value are number.",
                            "type": "boolean"
                        },
                        "containsNumber": {
                            "description": "Check if value are contains number.",
                            "type": "boolean"
                        }
                    },
                    "additionalProperties": false
                },
                "descriptionMarkdown": {
                    "type": "object",
                    "properties": {
                        "containsHeading1": {
                            "description": "Check if a markdown-string contains a heading.",
                            "type": "string"
                        },
                        "containsHeading2": {
                            "description": "Check if a markdown-string contains a heading.",
                            "type": "string"
                        },
                        "containsHeading3": {
                            "description": "Check if a markdown-string contains a heading.",
                            "type": "string"
                        },
                        "containsHeading4": {
                            "description": "Check if a markdown-string contains a heading.",
                            "type": "string"
                        },
                        "containsHeading5": {
                            "description": "Check if a markdown-string contains a heading.",
                            "type": "string"
                        },
                        "containsHeading6": {
                            "description": "Check if a markdown-string contains a heading.",
                            "type": "string"
                        }
                    },
                    "additionalProperties": false
                },
                "description": {
                    "type": "object",
                    "properties": {
                        "equals": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "=": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "lengthMin": {
                            "description": "Check the minimum string length.",
                            "type": "integer"
                        },
                        "lengthMax": {
                            "description": "Check the maximum string length.",
                            "type": "integer"
                        },
                        "starts": {
                            "description": "Check if a string contains a prefix.",
                            "type": "string"
                        },
                        "notStarts": {
                            "description": "Check if a string not contains a prefix.",
                            "type": "string"
                        },
                        "ends": {
                            "description": "Check if a string contains a suffix.",
                            "type": "string"
                        },
                        "notEnds": {
                            "description": "Check if a string not contains a suffix.",
                            "type": "string"
                        },
                        "contains": {
                            "description": "Check if a string contains a substring.",
                            "type": "string"
                        },
                        "notEquals": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "!=": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "equalsAny": {
                            "description": "Check if the field is equal to one of the values.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "match": {
                            "description": "Check if a string match a regex.",
                            "type": "string"
                        },
                        "isEmpty": {
                            "description": "Check if a value is empty.",
                            "type": "boolean"
                        },
                        "isCamelCase": {
                            "description": "Check if a string is camelCase.",
                            "type": "boolean"
                        },
                        "isStudlyCase": {
                            "description": "Check if a string is StudlyCase.",
                            "type": "boolean"
                        },
                        "isUpperCase": {
                            "description": "Check if a string is upper case.",
                            "type": "boolean"
                        },
                        "isLowerCase": {
                            "description": "Check if a string is lower case.",
                            "type": "boolean"
                        },
                        "isSnakeCase": {
                            "description": "Check if a string is snake_case.",
                            "type": "boolean"
                        },
                        "isKebabCase": {
                            "description": "Check if a string is kebab-case.",
                            "type": "boolean"
                        },
                        "linesMax": {
                            "description": "Check the maximum string lines.",
                            "type": "integer"
                        },
                        "containsLine": {
                            "description": "Check if a string contains a line.",
                            "type": "string"
                        },
                        "notStartsAny": {
                            "description": "Check if a string not contains a prefixes.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "isNumber": {
                            "description": "Check if value are number.",
                            "type": "boolean"
                        },
                        "containsNumber": {
                            "description": "Check if value are contains number.",
                            "type": "boolean"
                        }
                    },
                    "additionalProperties": false
                },
                "labels": {
                    "type": "object",
                    "properties": {
                        "countMin": {
                            "description": "Check the minimum number of elements in a field.",
                            "type": "integer"
                        },
                        "countMax": {
                            "description": "Check the maximum number of elements in a field.",
                            "type": "integer"
                        },
                        "countEquals": {
                            "description": "Check count equals.",
                            "type": "integer"
                        },
                        "countNotEquals": {
                            "description": "Check count not equals.",
                            "type": "integer"
                        },
                        "countEqualsAny": {
                            "description": "Check count equals.",
                            "type": "array",
                            "items": {
                                "type": "integer"
                            }
                        },
                        "has": {
                            "description": "Check if an array contains some value.",
                            "type": "string"
                        },
                        "notHas": {
                            "description": "Check if an array not contains some value.",
                            "type": "string"
                        },
                        "hasAny": {
                            "description": "Check if an array contains some value of list.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "notHasAny": {
                            "description": "Check if an array not contains values of list.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "isEmpty": {
                            "description": "Check if a value is empty.",
                            "type": "boolean"
                        },
                        "$all": {
                            "description": "True if all values of array matched conditions.",
                            "type": "object",
                            "properties": {
                                "equals": {
                                    "description": "Check if value are equal.",
                                    "type": "string"
                                },
                                "=": {
                                    "description": "Check if value are equal.",
                                    "type": "string"
                                },
                                "lengthMin": {
                                    "description": "Check the minimum string length.",
                                    "type": "integer"
                                },
                                "lengthMax": {
                                    "description": "Check the maximum string length.",
                                    "type": "integer"
                                },
                                "starts": {
                                    "description": "Check if a string contains a prefix.",
                                    "type": "string"
                                },
                                "notStarts": {
                                    "description": "Check if a string not contains a prefix.",
                                    "type": "string"
                                },
                                "ends": {
                                    "description": "Check if a string contains a suffix.",
                                    "type": "string"
                                },
                                "notEnds": {
                                    "description": "Check if a string not contains a suffix.",
                                    "type": "string"
                                },
                                "contains": {
                                    "description": "Check if a string contains a substring.",
                                    "type": "string"
                                },
                                "notEquals": {
                                    "description": "Check if value are not equal.",
                                    "type": "string"
                                },
                                "!=": {
                                    "description": "Check if value are not equal.",
                                    "type": "string"
                                },
                                "equalsAny": {
                                    "description": "Check if the field is equal to one of the values.",
                                    "type": "string"
                                },
                                "match": {
                                    "description": "Check if a string match a regex.",
                                    "type": "string"
                                },
                                "isEmpty": {
                                    "description": "Check if a value is empty.",
                                    "type": "boolean"
                                },
                                "isCamelCase": {
                                    "description": "Check if a string is camelCase.",
                                    "type": "boolean"
                                },
                                "isStudlyCase": {
                                    "description": "Check if a string is StudlyCase.",
                                    "type": "boolean"
                                },
                                "isUpperCase": {
                                    "description": "Check if a string is upper case.",
                                    "type": "boolean"
                                },
                                "isLowerCase": {
                                    "description": "Check if a string is lower case.",
                                    "type": "boolean"
                                },
                                "isSnakeCase": {
                                    "description": "Check if a string is snake_case.",
                                    "type": "boolean"
                                },
                                "isKebabCase": {
                                    "description": "Check if a string is kebab-case.",
                                    "type": "boolean"
                                },
                                "linesMax": {
                                    "description": "Check the maximum string lines.",
                                    "type": "integer"
                                },
                                "containsLine": {
                                    "description": "Check if a string contains a line.",
                                    "type": "string"
                                },
                                "notStartsAny": {
                                    "description": "Check if a string not contains a prefixes.",
                                    "type": "string"
                                },
                                "isNumber": {
                                    "description": "Check if value are number.",
                                    "type": "boolean"
                                },
                                "containsNumber": {
                                    "description": "Check if value are contains number.",
                                    "type": "boolean"
                                }
                            },
                            "additionalProperties": false
                        },
                        "$any": {
                            "description": "True if any value of array matched conditions.",
                            "type": "object",
                            "properties": {
                                "equals": {
                                    "description": "Check if value are equal.",
                                    "type": "string"
                                },
                                "=": {
                                    "description": "Check if value are equal.",
                                    "type": "string"
                                },
                                "lengthMin": {
                                    "description": "Check the minimum string length.",
                                    "type": "integer"
                                },
                                "lengthMax": {
                                    "description": "Check the maximum string length.",
                                    "type": "integer"
                                },
                                "starts": {
                                    "description": "Check if a string contains a prefix.",
                                    "type": "string"
                                },
                                "notStarts": {
                                    "description": "Check if a string not contains a prefix.",
                                    "type": "string"
                                },
                                "ends": {
                                    "description": "Check if a string contains a suffix.",
                                    "type": "string"
                                },
                                "notEnds": {
                                    "description": "Check if a string not contains a suffix.",
                                    "type": "string"
                                },
                                "contains": {
                                    "description": "Check if a string contains a substring.",
                                    "type": "string"
                                },
                                "notEquals": {
                                    "description": "Check if value are not equal.",
                                    "type": "string"
                                },
                                "!=": {
                                    "description": "Check if value are not equal.",
                                    "type": "string"
                                },
                                "equalsAny": {
                                    "description": "Check if the field is equal to one of the values.",
                                    "type": "string"
                                },
                                "match": {
                                    "description": "Check if a string match a regex.",
                                    "type": "string"
                                },
                                "isEmpty": {
                                    "description": "Check if a value is empty.",
                                    "type": "boolean"
                                },
                                "isCamelCase": {
                                    "description": "Check if a string is camelCase.",
                                    "type": "boolean"
                                },
                                "isStudlyCase": {
                                    "description": "Check if a string is StudlyCase.",
                                    "type": "boolean"
                                },
                                "isUpperCase": {
                                    "description": "Check if a string is upper case.",
                                    "type": "boolean"
                                },
                                "isLowerCase": {
                                    "description": "Check if a string is lower case.",
                                    "type": "boolean"
                                },
                                "isSnakeCase": {
                                    "description": "Check if a string is snake_case.",
                                    "type": "boolean"
                                },
                                "isKebabCase": {
                                    "description": "Check if a string is kebab-case.",
                                    "type": "boolean"
                                },
                                "linesMax": {
                                    "description": "Check the maximum string lines.",
                                    "type": "integer"
                                },
                                "containsLine": {
                                    "description": "Check if a string contains a line.",
                                    "type": "string"
                                },
                                "notStartsAny": {
                                    "description": "Check if a string not contains a prefixes.",
                                    "type": "string"
                                },
                                "isNumber": {
                                    "description": "Check if value are number.",
                                    "type": "boolean"
                                },
                                "containsNumber": {
                                    "description": "Check if value are contains number.",
                                    "type": "boolean"
                                }
                            },
                            "additionalProperties": false
                        },
                        "notIntersect": {
                            "description": "Check that the array does not intersect with the user array.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        }
                    },
                    "additionalProperties": false
                },
                "hasConflicts": {
                    "type": "object",
                    "properties": {
                        "equals": {
                            "description": "Check if value are equal.",
                            "type": "boolean"
                        },
                        "=": {
                            "description": "Check if value are equal.",
                            "type": "boolean"
                        },
                        "notEquals": {
                            "description": "Check if value are not equal.",
                            "type": "boolean"
                        },
                        "!=": {
                            "description": "Check if value are not equal.",
                            "type": "boolean"
                        }
                    },
                    "additionalProperties": false
                },
                "sourceBranch": {
                    "type": "object",
                    "properties": {
                        "equals": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "=": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "lengthMin": {
                            "description": "Check the minimum string length.",
                            "type": "integer"
                        },
                        "lengthMax": {
                            "description": "Check the maximum string length.",
                            "type": "integer"
                        },
                        "starts": {
                            "description": "Check if a string contains a prefix.",
                            "type": "string"
                        },
                        "notStarts": {
                            "description": "Check if a string not contains a prefix.",
                            "type": "string"
                        },
                        "ends": {
                            "description": "Check if a string contains a suffix.",
                            "type": "string"
                        },
                        "notEnds": {
                            "description": "Check if a string not contains a suffix.",
                            "type": "string"
                        },
                        "contains": {
                            "description": "Check if a string contains a substring.",
                            "type": "string"
                        },
                        "notEquals": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "!=": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "equalsAny": {
                            "description": "Check if the field is equal to one of the values.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "match": {
                            "description": "Check if a string match a regex.",
                            "type": "string"
                        },
                        "isEmpty": {
                            "description": "Check if a value is empty.",
                            "type": "boolean"
                        },
                        "isCamelCase": {
                            "description": "Check if a string is camelCase.",
                            "type": "boolean"
                        },
                        "isStudlyCase": {
                            "description": "Check if a string is StudlyCase.",
                            "type": "boolean"
                        },
                        "isUpperCase": {
                            "description": "Check if a string is upper case.",
                            "type": "boolean"
                        },
                        "isLowerCase": {
                            "description": "Check if a string is lower case.",
                            "type": "boolean"
                        },
                        "isSnakeCase": {
                            "description": "Check if a string is snake_case.",
                            "type": "boolean"
                        },
                        "isKebabCase": {
                            "description": "Check if a string is kebab-case.",
                            "type": "boolean"
                        },
                        "linesMax": {
                            "description": "Check the maximum string lines.",
                            "type": "integer"
                        },
                        "containsLine": {
                            "description": "Check if a string contains a line.",
                            "type": "string"
                        },
                        "notStartsAny": {
                            "description": "Check if a string not contains a prefixes.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "isNumber": {
                            "description": "Check if value are number.",
                            "type": "boolean"
                        },
                        "containsNumber": {
                            "description": "Check if value are contains number.",
                            "type": "boolean"
                        }
                    },
                    "additionalProperties": false
                },
                "targetBranch": {
                    "type": "object",
                    "properties": {
                        "equals": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "=": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "lengthMin": {
                            "description": "Check the minimum string length.",
                            "type": "integer"
                        },
                        "lengthMax": {
                            "description": "Check the maximum string length.",
                            "type": "integer"
                        },
                        "starts": {
                            "description": "Check if a string contains a prefix.",
                            "type": "string"
                        },
                        "notStarts": {
                            "description": "Check if a string not contains a prefix.",
                            "type": "string"
                        },
                        "ends": {
                            "description": "Check if a string contains a suffix.",
                            "type": "string"
                        },
                        "notEnds": {
                            "description": "Check if a string not contains a suffix.",
                            "type": "string"
                        },
                        "contains": {
                            "description": "Check if a string contains a substring.",
                            "type": "string"
                        },
                        "notEquals": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "!=": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "equalsAny": {
                            "description": "Check if the field is equal to one of the values.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "match": {
                            "description": "Check if a string match a regex.",
                            "type": "string"
                        },
                        "isEmpty": {
                            "description": "Check if a value is empty.",
                            "type": "boolean"
                        },
                        "isCamelCase": {
                            "description": "Check if a string is camelCase.",
                            "type": "boolean"
                        },
                        "isStudlyCase": {
                            "description": "Check if a string is StudlyCase.",
                            "type": "boolean"
                        },
                        "isUpperCase": {
                            "description": "Check if a string is upper case.",
                            "type": "boolean"
                        },
                        "isLowerCase": {
                            "description": "Check if a string is lower case.",
                            "type": "boolean"
                        },
                        "isSnakeCase": {
                            "description": "Check if a string is snake_case.",
                            "type": "boolean"
                        },
                        "isKebabCase": {
                            "description": "Check if a string is kebab-case.",
                            "type": "boolean"
                        },
                        "linesMax": {
                            "description": "Check the maximum string lines.",
                            "type": "integer"
                        },
                        "containsLine": {
                            "description": "Check if a string contains a line.",
                            "type": "string"
                        },
                        "notStartsAny": {
                            "description": "Check if a string not contains a prefixes.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "isNumber": {
                            "description": "Check if value are number.",
                            "type": "boolean"
                        },
                        "containsNumber": {
                            "description": "Check if value are contains number.",
                            "type": "boolean"
                        }
                    },
                    "additionalProperties": false
                },
                "author.login": {
                    "type": "object",
                    "properties": {
                        "equals": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "=": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "lengthMin": {
                            "description": "Check the minimum string length.",
                            "type": "integer"
                        },
                        "lengthMax": {
                            "description": "Check the maximum string length.",
                            "type": "integer"
                        },
                        "starts": {
                            "description": "Check if a string contains a prefix.",
                            "type": "string"
                        },
                        "notStarts": {
                            "description": "Check if a string not contains a prefix.",
                            "type": "string"
                        },
                        "ends": {
                            "description": "Check if a string contains a suffix.",
                            "type": "string"
                        },
                        "notEnds": {
                            "description": "Check if a string not contains a suffix.",
                            "type": "string"
                        },
                        "contains": {
                            "description": "Check if a string contains a substring.",
                            "type": "string"
                        },
                        "notEquals": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "!=": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "equalsAny": {
                            "description": "Check if the field is equal to one of the values.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "match": {
                            "description": "Check if a string match a regex.",
                            "type": "string"
                        },
                        "isEmpty": {
                            "description": "Check if a value is empty.",
                            "type": "boolean"
                        },
                        "isCamelCase": {
                            "description": "Check if a string is camelCase.",
                            "type": "boolean"
                        },
                        "isStudlyCase": {
                            "description": "Check if a string is StudlyCase.",
                            "type": "boolean"
                        },
                        "isUpperCase": {
                            "description": "Check if a string is upper case.",
                            "type": "boolean"
                        },
                        "isLowerCase": {
                            "description": "Check if a string is lower case.",
                            "type": "boolean"
                        },
                        "isSnakeCase": {
                            "description": "Check if a string is snake_case.",
                            "type": "boolean"
                        },
                        "isKebabCase": {
                            "description": "Check if a string is kebab-case.",
                            "type": "boolean"
                        },
                        "linesMax": {
                            "description": "Check the maximum string lines.",
                            "type": "integer"
                        },
                        "containsLine": {
                            "description": "Check if a string contains a line.",
                            "type": "string"
                        },
                        "notStartsAny": {
                            "description": "Check if a string not contains a prefixes.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "isNumber": {
                            "description": "Check if value are number.",
                            "type": "boolean"
                        },
                        "containsNumber": {
                            "description": "Check if value are contains number.",
                            "type": "boolean"
                        }
                    },
                    "additionalProperties": false
                },
                "isDraft": {
                    "type": "object",
                    "properties": {
                        "equals": {
                            "description": "Check if value are equal.",
                            "type": "boolean"
                        },
                        "=": {
                            "description": "Check if value are equal.",
                            "type": "boolean"
                        },
                        "notEquals": {
                            "description": "Check if value are not equal.",
                            "type": "boolean"
                        },
                        "!=": {
                            "description": "Check if value are not equal.",
                            "type": "boolean"
                        }
                    },
                    "additionalProperties": false
                },
                "canMerge": {
                    "type": "object",
                    "properties": {
                        "equals": {
                            "description": "Check if value are equal.",
                            "type": "boolean"
                        },
                        "=": {
                            "description": "Check if value are equal.",
                            "type": "boolean"
                        },
                        "notEquals": {
                            "description": "Check if value are not equal.",
                            "type": "boolean"
                        },
                        "!=": {
                            "description": "Check if value are not equal.",
                            "type": "boolean"
                        }
                    },
                    "additionalProperties": false
                },
                "changes": {
                    "type": "object",
                    "properties": {
                        "countMin": {
                            "description": "Check the minimum number of elements in a field.",
                            "type": "integer"
                        },
                        "countMax": {
                            "description": "Check the maximum number of elements in a field.",
                            "type": "integer"
                        },
                        "countEquals": {
                            "description": "Check count equals.",
                            "type": "integer"
                        },
                        "countNotEquals": {
                            "description": "Check count not equals.",
                            "type": "integer"
                        },
                        "countEqualsAny": {
                            "description": "Check count equals.",
                            "type": "array",
                            "items": {
                                "type": "integer"
                            }
                        },
                        "has": {
                            "description": "Check if an array contains some value.",
                            "type": "object"
                        },
                        "notHas": {
                            "description": "Check if an array not contains some value.",
                            "type": "object"
                        },
                        "hasAny": {
                            "description": "Check if an array contains some value of list.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "notHasAny": {
                            "description": "Check if an array not contains values of list.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "isEmpty": {
                            "description": "Check if a value is empty.",
                            "type": "boolean"
                        },
                        "notIntersect": {
                            "description": "Check that the array does not intersect with the user array.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        }
                    },
                    "additionalProperties": false
                },
                "uri": {
                    "type": "object",
                    "properties": {
                        "equals": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "=": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "lengthMin": {
                            "description": "Check the minimum string length.",
                            "type": "integer"
                        },
                        "lengthMax": {
                            "description": "Check the maximum string length.",
                            "type": "integer"
                        },
                        "starts": {
                            "description": "Check if a string contains a prefix.",
                            "type": "string"
                        },
                        "notStarts": {
                            "description": "Check if a string not contains a prefix.",
                            "type": "string"
                        },
                        "ends": {
                            "description": "Check if a string contains a suffix.",
                            "type": "string"
                        },
                        "notEnds": {
                            "description": "Check if a string not contains a suffix.",
                            "type": "string"
                        },
                        "contains": {
                            "description": "Check if a string contains a substring.",
                            "type": "string"
                        },
                        "notEquals": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "!=": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "equalsAny": {
                            "description": "Check if the field is equal to one of the values.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "match": {
                            "description": "Check if a string match a regex.",
                            "type": "string"
                        },
                        "isEmpty": {
                            "description": "Check if a value is empty.",
                            "type": "boolean"
                        },
                        "isCamelCase": {
                            "description": "Check if a string is camelCase.",
                            "type": "boolean"
                        },
                        "isStudlyCase": {
                            "description": "Check if a string is StudlyCase.",
                            "type": "boolean"
                        },
                        "isUpperCase": {
                            "description": "Check if a string is upper case.",
                            "type": "boolean"
                        },
                        "isLowerCase": {
                            "description": "Check if a string is lower case.",
                            "type": "boolean"
                        },
                        "isSnakeCase": {
                            "description": "Check if a string is snake_case.",
                            "type": "boolean"
                        },
                        "isKebabCase": {
                            "description": "Check if a string is kebab-case.",
                            "type": "boolean"
                        },
                        "linesMax": {
                            "description": "Check the maximum string lines.",
                            "type": "integer"
                        },
                        "containsLine": {
                            "description": "Check if a string contains a line.",
                            "type": "string"
                        },
                        "notStartsAny": {
                            "description": "Check if a string not contains a prefixes.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "isNumber": {
                            "description": "Check if value are number.",
                            "type": "boolean"
                        },
                        "containsNumber": {
                            "description": "Check if value are contains number.",
                            "type": "boolean"
                        }
                    },
                    "additionalProperties": false
                },
                "id": {
                    "type": "object",
                    "properties": {
                        "equals": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "=": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "lengthMin": {
                            "description": "Check the minimum string length.",
                            "type": "integer"
                        },
                        "lengthMax": {
                            "description": "Check the maximum string length.",
                            "type": "integer"
                        },
                        "starts": {
                            "description": "Check if a string contains a prefix.",
                            "type": "string"
                        },
                        "notStarts": {
                            "description": "Check if a string not contains a prefix.",
                            "type": "string"
                        },
                        "ends": {
                            "description": "Check if a string contains a suffix.",
                            "type": "string"
                        },
                        "notEnds": {
                            "description": "Check if a string not contains a suffix.",
                            "type": "string"
                        },
                        "contains": {
                            "description": "Check if a string contains a substring.",
                            "type": "string"
                        },
                        "notEquals": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "!=": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "equalsAny": {
                            "description": "Check if the field is equal to one of the values.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "match": {
                            "description": "Check if a string match a regex.",
                            "type": "string"
                        },
                        "isEmpty": {
                            "description": "Check if a value is empty.",
                            "type": "boolean"
                        },
                        "isCamelCase": {
                            "description": "Check if a string is camelCase.",
                            "type": "boolean"
                        },
                        "isStudlyCase": {
                            "description": "Check if a string is StudlyCase.",
                            "type": "boolean"
                        },
                        "isUpperCase": {
                            "description": "Check if a string is upper case.",
                            "type": "boolean"
                        },
                        "isLowerCase": {
                            "description": "Check if a string is lower case.",
                            "type": "boolean"
                        },
                        "isSnakeCase": {
                            "description": "Check if a string is snake_case.",
                            "type": "boolean"
                        },
                        "isKebabCase": {
                            "description": "Check if a string is kebab-case.",
                            "type": "boolean"
                        },
                        "linesMax": {
                            "description": "Check the maximum string lines.",
                            "type": "integer"
                        },
                        "containsLine": {
                            "description": "Check if a string contains a line.",
                            "type": "string"
                        },
                        "notStartsAny": {
                            "description": "Check if a string not contains a prefixes.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "isNumber": {
                            "description": "Check if value are number.",
                            "type": "boolean"
                        },
                        "containsNumber": {
                            "description": "Check if value are contains number.",
                            "type": "boolean"
                        }
                    },
                    "additionalProperties": false
                },
                "number": {
                    "type": "object",
                    "properties": {
                        "equals": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "=": {
                            "description": "Check if value are equal.",
                            "type": "string"
                        },
                        "lengthMin": {
                            "description": "Check the minimum string length.",
                            "type": "integer"
                        },
                        "lengthMax": {
                            "description": "Check the maximum string length.",
                            "type": "integer"
                        },
                        "starts": {
                            "description": "Check if a string contains a prefix.",
                            "type": "string"
                        },
                        "notStarts": {
                            "description": "Check if a string not contains a prefix.",
                            "type": "string"
                        },
                        "ends": {
                            "description": "Check if a string contains a suffix.",
                            "type": "string"
                        },
                        "notEnds": {
                            "description": "Check if a string not contains a suffix.",
                            "type": "string"
                        },
                        "contains": {
                            "description": "Check if a string contains a substring.",
                            "type": "string"
                        },
                        "notEquals": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "!=": {
                            "description": "Check if value are not equal.",
                            "type": "string"
                        },
                        "equalsAny": {
                            "description": "Check if the field is equal to one of the values.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "match": {
                            "description": "Check if a string match a regex.",
                            "type": "string"
                        },
                        "isEmpty": {
                            "description": "Check if a value is empty.",
                            "type": "boolean"
                        },
                        "isCamelCase": {
                            "description": "Check if a string is camelCase.",
                            "type": "boolean"
                        },
                        "isStudlyCase": {
                            "description": "Check if a string is StudlyCase.",
                            "type": "boolean"
                        },
                        "isUpperCase": {
                            "description": "Check if a string is upper case.",
                            "type": "boolean"
                        },
                        "isLowerCase": {
                            "description": "Check if a string is lower case.",
                            "type": "boolean"
                        },
                        "isSnakeCase": {
                            "description": "Check if a string is snake_case.",
                            "type": "boolean"
                        },
                        "isKebabCase": {
                            "description": "Check if a string is kebab-case.",
                            "type": "boolean"
                        },
                        "linesMax": {
                            "description": "Check the maximum string lines.",
                            "type": "integer"
                        },
                        "containsLine": {
                            "description": "Check if a string contains a line.",
                            "type": "string"
                        },
                        "notStartsAny": {
                            "description": "Check if a string not contains a prefixes.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "isNumber": {
                            "description": "Check if value are number.",
                            "type": "boolean"
                        },
                        "containsNumber": {
                            "description": "Check if value are contains number.",
                            "type": "boolean"
                        }
                    },
                    "additionalProperties": false
                }
            },
            "additionalProperties": false
        },
        "rules_properties_@mr-linter_changed_files_limit": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "limit": {
                    "type": "integer",
                    "description": "Number of maximum possible changes"
                }
            },
            "additionalProperties": false,
            "required": [
                "limit"
            ]
        },
        "rules_properties_@mr-linter_description_contains_links_of_any_domains": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "domains": {
                    "type": "array",
                    "description": "Array of domains",
                    "items": [
                        {
                            "type": "string",
                            "description": "Array of domains",
                            "examples": [
                                "host.name"
                            ]
                        }
                    ]
                }
            },
            "additionalProperties": false,
            "required": [
                "domains"
            ]
        },
        "rules_properties_@mr-linter_description_contains_links_of_all_domains": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "domains": {
                    "type": "array",
                    "description": "Array of domains",
                    "items": [
                        {
                            "type": "string",
                            "description": "Array of domains",
                            "examples": [
                                "host.name"
                            ]
                        }
                    ]
                }
            },
            "additionalProperties": false,
            "required": [
                "domains"
            ]
        },
        "rules_properties_@mr-linter_description_not_empty": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                }
            },
            "additionalProperties": false
        },
        "rules_properties_@mr-linter_has_any_labels": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "labels": {
                    "type": "array",
                    "description": "Array of labels",
                    "items": [
                        {
                            "type": "string",
                            "description": "Array of labels",
                            "examples": [
                                "Feature",
                                "Bug"
                            ]
                        }
                    ]
                }
            },
            "additionalProperties": false,
            "required": [
                "labels"
            ]
        },
        "rules_properties_@mr-linter_jira_has_issue_link": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "domain": {
                    "type": "string",
                    "description": "Domain of Jira instance",
                    "examples": [
                        "jira.my-company.com"
                    ]
                },
                "projectCodes": {
                    "type": "array",
                    "description": "Project code",
                    "items": [
                        {
                            "type": "string",
                            "description": "Project code",
                            "examples": [
                                "ABC"
                            ]
                        }
                    ]
                }
            },
            "additionalProperties": false,
            "required": [
                "domain"
            ]
        },
        "rules_properties_@mr-linter_youtrack_has_issue_link": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "domain": {
                    "type": "string",
                    "description": "Domain hosting the YouTrack instance",
                    "examples": [
                        "yt.my-company.ru"
                    ]
                },
                "projectCodes": {
                    "type": "array",
                    "description": "Project code",
                    "items": [
                        {
                            "type": "string",
                            "description": "Project code",
                            "examples": [
                                "PORTAL"
                            ]
                        }
                    ]
                }
            },
            "additionalProperties": false,
            "required": [
                "domain"
            ]
        },
        "rules_properties_@mr-linter_title_must_starts_with_any_prefix": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "prefixes": {
                    "type": "array",
                    "description": "Array of prefixes",
                    "items": [
                        {
                            "type": "string",
                            "description": "Array of prefixes"
                        }
                    ]
                }
            },
            "additionalProperties": false,
            "required": [
                "prefixes"
            ]
        },
        "rules_properties_@mr-linter_has_changes": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "changes": {
                    "type": "array",
                    "description": "Array of need changes",
                    "items": {
                        "type": "object",
                        "properties": {
                            "file": {
                                "type": "string"
                            },
                            "contains": {
                                "type": "string"
                            },
                            "containsRegex": {
                                "type": "string"
                            },
                            "updatedPhpConstant": {
                                "type": "string"
                            }
                        },
                        "additionalProperties": false
                    }
                }
            },
            "additionalProperties": false,
            "required": [
                "changes"
            ]
        },
        "rules_properties_custom": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "rules": {
                    "$ref": "#/definitions/rule_conditions"
                },
                "definition": {
                    "type": "string",
                    "description": "Description about rule was failed"
                }
            },
            "additionalProperties": false,
            "required": [
                "rules",
                "definition"
            ]
        },
        "rules_properties_@mr-linter_title_starts_with_task_number": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "projectCodes": {
                    "type": "array",
                    "description": "Project codes. Empty list allowed for any projects",
                    "items": [
                        {
                            "type": "string",
                            "description": "Project codes. Empty list allowed for any projects",
                            "examples": [
                                "ABC"
                            ]
                        }
                    ]
                }
            },
            "additionalProperties": false
        },
        "rules_properties_@mr-linter_branch_starts_with_task_number": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "projectCodes": {
                    "type": "array",
                    "description": "Project codes. Empty list allowed for any projects",
                    "items": [
                        {
                            "type": "string",
                            "description": "Project codes. Empty list allowed for any projects",
                            "examples": [
                                "ABC"
                            ]
                        }
                    ]
                }
            },
            "additionalProperties": false
        },
        "rules_properties_@mr-linter_forbid_changes": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "files": {
                    "type": "array",
                    "description": "A set of files forbidden to be changed.",
                    "items": [
                        {
                            "type": "string",
                            "description": "A set of files forbidden to be changed."
                        }
                    ]
                }
            },
            "additionalProperties": false,
            "required": [
                "files"
            ]
        },
        "rules_properties_@mr-linter_changelog_has_new_release": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "file": {
                    "type": "string",
                    "description": "Relative path to changelog file",
                    "examples": [
                        "CHANGELOG.md"
                    ]
                },
                "changes": {
                    "type": "object",
                    "description": "Configuration for changes reading",
                    "properties": {
                        "types": {
                            "type": "array",
                            "description": "Set of allowed change types"
                        }
                    }
                }
            },
            "additionalProperties": false
        },
        "rules_properties_@mr-linter_diff_limit": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "linesMax": {
                    "type": "integer",
                    "description": "Maximum allowed number of changed lines"
                },
                "fileLinesMax": {
                    "type": "integer",
                    "description": "Maximum allowed number of changed lines in a file"
                }
            },
            "additionalProperties": false
        },
        "rules_properties_@mr-linter_no_ssh_keys": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "stopOnFirstFailure": {
                    "type": "boolean",
                    "description": "When the value is true, the search will stop after the first found key"
                }
            },
            "additionalProperties": false,
            "required": [
                "stopOnFirstFailure"
            ]
        },
        "rules_properties_@mr-linter_disable_file_extensions": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "extensions": {
                    "type": "array",
                    "description": "Array of file extensions",
                    "items": [
                        {
                            "type": "string",
                            "description": "Array of file extensions",
                            "examples": [
                                "pem",
                                "pub",
                                "php"
                            ]
                        }
                    ]
                }
            },
            "additionalProperties": false,
            "required": [
                "extensions"
            ]
        },
        "rules_properties_@mr-linter_title_conventional": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "types": {
                    "type": "array",
                    "description": "Commit types",
                    "items": [
                        {
                            "type": "string",
                            "description": "Commit types",
                            "examples": [
                                "build",
                                "chore",
                                "ci",
                                "docs",
                                "feat",
                                "fix",
                                "perf",
                                "refactor",
                                "revert",
                                "style",
                                "test"
                            ]
                        }
                    ]
                },
                "task": {
                    "type": "object",
                    "description": "Check if title contains task number",
                    "properties": {
                        "projectCodes": {
                            "type": "array",
                            "description": "Project codes. Empty list allowed for any projects",
                            "items": [
                                {
                                    "type": "string",
                                    "description": "Project codes. Empty list allowed for any projects",
                                    "examples": [
                                        "ABC"
                                    ]
                                }
                            ]
                        }
                    }
                }
            },
            "additionalProperties": false
        },
        "rules_properties_@mr-linter_description_template": {
            "type": "object",
            "properties": {
                "critical": {
                    "type": "boolean",
                    "default": true
                },
                "when": {
                    "description": "Conditions that determine whether the rule should run.",
                    "$ref": "#/definitions/rule_conditions"
                },
                "template": {
                    "type": "string",
                    "description": "Template for description"
                },
                "definition": {
                    "type": "string",
                    "description": "Custom definition"
                }
            },
            "additionalProperties": false,
            "required": [
                "template"
            ]
        },
        "notifications_channel_telegram_bot": {
            "properties": {
                "type": {
                    "type": "string",
                    "const": "telegram_bot"
                },
                "bot_token": {
                    "type": "string"
                },
                "chat_id": {
                    "type": "string"
                },
                "sound_at": {
                    "type": "string",
                    "description": "Time Period for enable sound. Example: 09:00-21:00"
                }
            }
        },
        "notifications_channel": {
            "type": "object",
            "oneOf": [
                {
                    "$ref": "#/definitions/notifications_channel_telegram_bot"
                }
            ]
        }
    },
    "required": [
        "rules",
        "ci"
    ]
}