{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://catalog.lintel.tools/schemas/schemastore/yamllint/latest.json",
  "title": "yamllint",
  "description": "yamllint uses a set of rules to check YAML source files for problems.",
  "x-lintel": {
    "source": "https://www.schemastore.org/yamllint.json",
    "sourceSha256": "75a84d8833de72906f5b8c0bbea0509b6445a05721ec2cf42febcdf31bc5a3dc",
    "fileMatch": [
      "**/.yamllint",
      "**/.yamllint.yaml",
      "**/.yamllint.yml"
    ],
    "parsers": [
      "yaml"
    ]
  },
  "type": "object",
  "properties": {
    "extends": {
      "description": "When writing a custom configuration file, you don’t need to redefine every rule. Just extend the default configuration (or any already-existing configuration file).",
      "type": "string",
      "default": "default",
      "examples": [
        "default",
        "relaxed"
      ]
    },
    "yaml-files": {
      "description": "To configure what yamllint should consider as YAML files when listing directories, set yaml-files configuration option.",
      "type": "array",
      "items": {
        "type": "string"
      },
      "default": [
        "*.yaml",
        "*.yml",
        ".yamllint"
      ]
    },
    "locale": {
      "description": "This is passed to Python's locale.setlocale.",
      "type": "string",
      "examples": [
        "en_US.UTF-8"
      ]
    },
    "rules": {
      "description": "When linting a document with yamllint, a series of rules are checked against. A configuration file can be used to enable or disable these rules, to set their level (error or warning), but also to tweak their options.",
      "type": "object",
      "properties": {
        "anchors": {
          "description": "Use this rule to report duplicated anchors and aliases referencing undeclared anchors.",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "forbid-undeclared-aliases": {
                  "title": "Forbid Undeclared Aliases",
                  "description": "Set forbid-undeclared-aliases to true to avoid aliases that reference an anchor that hasn't been declared (either not declared at all, or declared later in the document).",
                  "type": "boolean",
                  "default": true
                },
                "forbid-duplicated-anchors": {
                  "title": "Forbid Duplicated Anchors",
                  "description": "Set forbid-duplicated-anchors to true to avoid duplications of a same anchor.",
                  "type": "boolean",
                  "default": false
                },
                "forbid-unused-anchors": {
                  "title": "Forbid Unused Anchors",
                  "description": "Set forbid-unused-anchors to true to avoid anchors being declared but not used anywhere in the YAML document via alias.",
                  "type": "boolean",
                  "default": false
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "braces": {
          "title": "Braces",
          "description": "Use this rule to control the use of flow mappings or number of spaces inside braces ({ and }).",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "forbid": {
                  "title": "Forbid",
                  "description": "forbid is used to forbid the use of flow mappings which are denoted by surrounding braces ({ and }). Use true to forbid the use of flow mappings completely. Use non-empty to forbid the use of all flow mappings except for empty ones.",
                  "default": false,
                  "oneOf": [
                    {
                      "type": "boolean"
                    },
                    {
                      "const": "non-empty"
                    }
                  ]
                },
                "min-spaces-inside": {
                  "title": "Minimum Spaces Inside",
                  "description": "min-spaces-inside defines the minimal number of spaces required inside braces.",
                  "type": "number",
                  "default": 0,
                  "minimum": 0
                },
                "max-spaces-inside": {
                  "title": "Maximum Spaces Inside",
                  "description": "max-spaces-inside defines the maximal number of spaces allowed inside braces.",
                  "type": "number",
                  "default": 0,
                  "minimum": 0
                },
                "min-spaces-inside-empty": {
                  "title": "Minimum Spaces Inside Empty",
                  "description": "min-spaces-inside-empty defines the minimal number of spaces required inside empty braces. (use -1 to default to the value for min-spaces-inside)",
                  "type": "number",
                  "default": -1,
                  "minimum": -1
                },
                "max-spaces-inside-empty": {
                  "title": "Maximum Spaces Inside Empty",
                  "description": "max-spaces-inside-empty defines the maximal number of spaces allowed inside empty braces. (use -1 to default to the value for max-spaces-inside)",
                  "type": "number",
                  "default": -1,
                  "minimum": -1
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "brackets": {
          "title": "Brackets",
          "description": "Use this rule to control the use of flow sequences or the number of spaces inside brackets ([ and ]).",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "forbid": {
                  "title": "Forbid",
                  "description": "forbid is used to forbid the use of flow sequences which are denoted by surrounding brackets ([ and ]). Use true to forbid the use of flow sequences completely. Use non-empty to forbid the use of all flow sequences except for empty ones.",
                  "default": false,
                  "oneOf": [
                    {
                      "type": "boolean"
                    },
                    {
                      "const": "non-empty"
                    }
                  ]
                },
                "min-spaces-inside": {
                  "title": "Minimum Spaces Inside",
                  "description": "min-spaces-inside defines the minimal number of spaces required inside brackets.",
                  "type": "number",
                  "default": 0,
                  "minimum": 0
                },
                "max-spaces-inside": {
                  "title": "Maximum Spaces Inside",
                  "description": "max-spaces-inside defines the maximal number of spaces allowed inside brackets.",
                  "type": "number",
                  "default": 0,
                  "minimum": 0
                },
                "min-spaces-inside-empty": {
                  "title": "Minimum Spaces Inside Empty",
                  "description": "min-spaces-inside-empty defines the minimal number of spaces required inside empty brackets. (use -1 to default to the value for min-spaces-inside)",
                  "type": "number",
                  "default": -1,
                  "minimum": -1
                },
                "max-spaces-inside-empty": {
                  "title": "Maximum Spaces Inside Empty",
                  "description": "max-spaces-inside-empty defines the maximal number of spaces allowed inside empty brackets. (use -1 to default to the value for max-spaces-inside)",
                  "type": "number",
                  "default": -1,
                  "minimum": -1
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "colons": {
          "title": "Colons",
          "description": "Use this rule to control the number of spaces before and after colons (:).",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "max-spaces-before": {
                  "title": "Maximum Spaces Before",
                  "description": "max-spaces-before defines the maximal number of spaces allowed before colons (use -1 to disable).",
                  "type": "number",
                  "minimum": -1,
                  "default": 0
                },
                "max-spaces-after": {
                  "title": "Maximum Spaces After",
                  "description": "max-spaces-after defines the maximal number of spaces allowed after colons (use -1 to disable).",
                  "type": "number",
                  "minimum": -1,
                  "default": 0
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "commas": {
          "title": "Commas",
          "description": "Use this rule to control the number of spaces before and after commas (,).",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "max-spaces-before": {
                  "title": "Maximum Spaces Before",
                  "description": "max-spaces-before defines the maximal number of spaces allowed before commas (use -1 to disable).",
                  "type": "number",
                  "minimum": -1,
                  "default": 0
                },
                "min-spaces-after": {
                  "title": "Minimum Spaces After",
                  "description": "min-spaces-after defines the minimal number of spaces required after commas.",
                  "type": "number",
                  "minimum": 0,
                  "default": 1
                },
                "max-spaces-after": {
                  "title": "Maximum Spaces After",
                  "description": "max-spaces-after defines the maximal number of spaces allowed after commas (use -1 to disable).",
                  "type": "number",
                  "minimum": -1,
                  "default": 1
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "comments": {
          "title": "Comments",
          "description": "Use this rule to control the position and formatting of comments.",
          "default": {
            "level": "warning"
          },
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "require-starting-space": {
                  "title": "Require Starting Space",
                  "description": "Use require-starting-space to require a space character right after the #. Set to true to enable, false to disable.",
                  "type": "boolean",
                  "default": true
                },
                "ignore-shebangs": {
                  "title": "Ignore Shebangs",
                  "description": "Use ignore-shebangs to ignore a shebang at the beginning of the file when require-starting-space is set.",
                  "type": "boolean",
                  "default": true
                },
                "min-spaces-from-content": {
                  "title": "Minimum Spaces From Content",
                  "description": "min-spaces-from-content is used to visually separate inline comments from content. It defines the minimal required number of spaces between a comment and its preceding content.",
                  "type": "number",
                  "minimum": 0,
                  "default": 2
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "comments-indentation": {
          "title": "Comments Indentation",
          "description": "Use this rule to force comments to be indented like content.",
          "default": {
            "level": "warning"
          },
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "unevaluatedProperties": false
            }
          ]
        },
        "document-end": {
          "title": "Document End",
          "description": "Use this rule to require or forbid the use of document end marker (...).",
          "default": "disable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "present": {
                  "title": "Present",
                  "description": "Set present to true when the document end marker is required, or to false when it is forbidden.",
                  "type": "boolean",
                  "default": true
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "document-start": {
          "title": "Document Start",
          "description": "Use this rule to require or forbid the use of document start marker (---).",
          "default": {
            "level": "warning"
          },
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "present": {
                  "title": "Present",
                  "description": "Set present to true when the document start marker is required, or to false when it is forbidden.",
                  "type": "boolean",
                  "default": true
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "empty-lines": {
          "title": "Empty Lines",
          "description": "Use this rule to set a maximal number of allowed consecutive blank lines.",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "max": {
                  "title": "Maximum",
                  "description": "max defines the maximal number of empty lines allowed in the document.",
                  "type": "number",
                  "minimum": 0,
                  "default": 2
                },
                "max-start": {
                  "title": "Maximum Start",
                  "description": "max-start defines the maximal number of empty lines allowed at the beginning of the file. This option takes precedence over max.",
                  "type": "number",
                  "minimum": 0,
                  "default": 0
                },
                "max-end": {
                  "title": "Maximum End",
                  "description": "max-end defines the maximal number of empty lines allowed at the end of the file. This option takes precedence over max.",
                  "type": "number",
                  "minimum": 0,
                  "default": 0
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "empty-values": {
          "title": "Empty Values",
          "description": "Use this rule to prevent nodes with empty content, that implicitly result in null values.",
          "default": "disable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "forbid-in-block-mappings": {
                  "title": "Forbid in Block Mappings",
                  "description": "Use forbid-in-block-mappings to prevent empty values in block mappings.",
                  "type": "boolean",
                  "default": true
                },
                "forbid-in-flow-mappings": {
                  "title": "Forbid in Flow Mappings",
                  "description": "Use forbid-in-flow-mappings to prevent empty values in flow mappings.",
                  "type": "boolean",
                  "default": true
                },
                "forbid-in-block-sequences": {
                  "title": "Forbid in Block Sequences",
                  "description": "Use forbid-in-block-sequences to prevent empty values in block sequences.",
                  "type": "boolean",
                  "default": true
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "float-values": {
          "title": "Float Values",
          "description": "Use this rule to limit the permitted values for floating-point numbers. YAML permits three classes of float expressions: approximation to real numbers, positive and negative infinity and \"not a number\".",
          "default": "disable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "require-numeral-before-decimal": {
                  "title": "Require Numeral Before Decimal",
                  "description": "Use require-numeral-before-decimal to require floats to start with a numeral (ex 0.0 instead of .0).",
                  "type": "boolean",
                  "default": false
                },
                "forbid-scientific-notation": {
                  "title": "Forbid Scientific Notation",
                  "description": "Use forbid-scientific-notation to forbid scientific notation.",
                  "type": "boolean",
                  "default": false
                },
                "forbid-nan": {
                  "title": "Forbid NaN",
                  "description": "Use forbid-nan to forbid NaN (not a number) values.",
                  "type": "boolean",
                  "default": false
                },
                "forbid-inf": {
                  "title": "Forbid Inf",
                  "description": "Use forbid-inf to forbid infinite values.",
                  "type": "boolean",
                  "default": false
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "hyphens": {
          "title": "Hyphens",
          "description": "Use this rule to control the number of spaces after hyphens (-).",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "max-spaces-after": {
                  "title": "Maximum Spaces After",
                  "description": "max-spaces-after defines the maximal number of spaces allowed after hyphens.",
                  "type": "number",
                  "minimum": 0,
                  "default": 1
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "indentation": {
          "title": "Indentation",
          "description": "Use this rule to control the indentation.",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "spaces": {
                  "title": "Spaces",
                  "description": "spaces defines the indentation width, in spaces. Set either to an integer (e.g. 2 or 4, representing the number of spaces in an indentation level) or to consistent to allow any number, as long as it remains the same within the file.",
                  "default": "consistent",
                  "oneOf": [
                    {
                      "type": "number",
                      "minimum": 1,
                      "examples": [
                        2,
                        4
                      ]
                    },
                    {
                      "description": "consistent allows any number of spaces, as long as it remains the same within the file.",
                      "const": "consistent"
                    }
                  ]
                },
                "indent-sequences": {
                  "title": "Indent Sequences",
                  "description": "indent-sequences defines whether block sequences should be indented or not (when in a mapping, this indentation is not mandatory - some people perceive the - as part of the indentation). Possible values: true, false, whatever and consistent.",
                  "default": true,
                  "oneOf": [
                    {
                      "type": "boolean"
                    },
                    {
                      "description": "consistent requires either all block sequences to be indented, or none to be.",
                      "const": "consistent"
                    },
                    {
                      "description": "whatever means either indenting or not indenting individual block sequences is OK.",
                      "const": "whatever"
                    }
                  ]
                },
                "check-multi-line-strings": {
                  "title": "Check Multi-Line Strings",
                  "description": "check-multi-line-strings defines whether to lint indentation in multi-line strings. Set to true to enable, false to disable.",
                  "type": "boolean",
                  "default": false
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "key-duplicates": {
          "title": "Key Duplicates",
          "description": "Use this rule to prevent multiple entries with the same key in mappings.",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "forbid-duplicated-merge-keys": {
                  "title": "Forbid Duplicated Merge Keys",
                  "description": "Use forbid-duplicated-merge-keys to forbid the usage of multiple merge keys <<.",
                  "type": "boolean",
                  "default": false
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "key-ordering": {
          "title": "Key Ordering",
          "description": "Use this rule to enforce alphabetical ordering of keys in mappings. The sorting order uses the Unicode code point number as a default. As a result, the ordering is case-sensitive and not accent-friendly (see examples below). This can be changed by setting the global locale option. This allows one to sort case and accents properly.",
          "default": "disable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "ignored-keys": {
                  "title": "Ignored Keys",
                  "description": "ignored-keys is a list of PCRE regexes to ignore some keys while checking order, if they match any regex.",
                  "type": "array",
                  "items": {
                    "description": "PCRE regex to ignore some keys while checking order.",
                    "type": "string",
                    "format": "regex"
                  },
                  "default": []
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "line-length": {
          "title": "Line Length",
          "description": "Use this rule to set a limit to lines length.",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "max": {
                  "title": "Maximum",
                  "description": "max defines the maximal (inclusive) length of lines.",
                  "type": "number",
                  "minimum": 0,
                  "default": 80
                },
                "allow-non-breakable-words": {
                  "title": "Allow Non-Breakable Words",
                  "description": "allow-non-breakable-words is used to allow non breakable words (without spaces inside) to overflow the limit. This is useful for long URLs, for instance. Use true to allow, false to forbid.",
                  "type": "boolean",
                  "default": true
                },
                "allow-non-breakable-inline-mappings": {
                  "title": "Allow Non-Breakable Inline Mappings",
                  "description": "allow-non-breakable-inline-mappings implies allow-non-breakable-words and extends it to also allow non-breakable words in inline mappings.",
                  "type": "boolean",
                  "default": false
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "new-line-at-end-of-file": {
          "title": "New Line At End Of File",
          "description": "Use this rule to require a new line character (\\n) at the end of files.\n\nThe POSIX standard requires the last line to end with a new line character. All UNIX tools expect a new line at the end of files. Most text editors use this convention too.",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "unevaluatedProperties": false
            }
          ]
        },
        "new-lines": {
          "title": "New Lines",
          "description": "Use this rule to force the type of new line characters.",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "type": {
                  "title": "Type",
                  "description": "Set type to unix to enforce UNIX-typed new line characters (\\n), set type to dos to enforce DOS-typed new line characters (\\r\\n), or set type to platform to infer the type from the system running yamllint (\\n on POSIX / UNIX / Linux / Mac OS systems or \\r\\n on DOS / Windows systems).",
                  "enum": [
                    "unix",
                    "dos",
                    "platform"
                  ],
                  "default": "unix"
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "octal-values": {
          "title": "Octal Values",
          "description": "Use this rule to prevent values with octal numbers. In YAML, numbers that start with 0 are interpreted as octal, but this is not always wanted. For instance 010 is the city code of Beijing, and should not be converted to 8.",
          "default": "disable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "forbid-implicit-octal": {
                  "title": "Forbid Implicit Octal",
                  "description": "Use forbid-implicit-octal to prevent numbers starting with 0.",
                  "type": "boolean",
                  "default": true
                },
                "forbid-explicit-octal": {
                  "title": "Forbid Explicit Octal",
                  "description": "Use forbid-explicit-octal to prevent numbers starting with 0o.",
                  "type": "boolean",
                  "default": false
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "quoted-strings": {
          "title": "Quoted Strings",
          "description": "Use this rule to forbid any string values that are not quoted, or to prevent quoted strings without needing it. You can also enforce the type of the quote used.",
          "default": "disable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "quote-type": {
                  "title": "Quote Type",
                  "description": "quote-type defines allowed quotes: single, double or any (default).",
                  "enum": [
                    "single",
                    "double",
                    "any"
                  ],
                  "default": "any"
                },
                "required": {
                  "title": "Required",
                  "description": "required defines whether using quotes in string values is required (true, default) or not (false), or only allowed when really needed (only-when-needed).",
                  "default": true,
                  "oneOf": [
                    {
                      "type": "boolean"
                    },
                    {
                      "const": "only-when-needed"
                    }
                  ]
                },
                "allow-quoted-quotes": {
                  "title": "Allow Quoted Quotes",
                  "description": "allow-quoted-quotes allows (true) using disallowed quotes for strings with allowed quotes inside. Default false.",
                  "type": "boolean",
                  "default": false
                },
                "check-keys": {
                  "title": "Check Keys",
                  "description": "check-keys defines whether to apply the rules to keys in mappings. By default, quoted-strings rules apply only to values. Set this option to true to apply the rules to keys as well.",
                  "type": "boolean",
                  "default": false
                }
              },
              "allOf": [
                {
                  "if": {
                    "properties": {
                      "required": {
                        "anyOf": [
                          {
                            "const": false
                          },
                          {
                            "const": "only-when-needed"
                          }
                        ]
                      }
                    }
                  },
                  "then": {
                    "properties": {
                      "extra-required": {
                        "title": "Extra Required",
                        "description": "extra-required is a list of PCRE regexes to force string values to be quoted, if they match any regex. This option can only be used with required: false and required: only-when-needed.",
                        "type": "array",
                        "items": {
                          "description": "PCRE regex to force string values to be quoted.",
                          "type": "string",
                          "format": "regex"
                        },
                        "default": []
                      }
                    }
                  }
                },
                {
                  "if": {
                    "properties": {
                      "required": {
                        "const": "only-when-needed"
                      }
                    }
                  },
                  "then": {
                    "properties": {
                      "extra-allowed": {
                        "title": "Extra Allowed",
                        "description": "extra-allowed is a list of PCRE regexes to allow quoted string values, even if required: only-when-needed is set.",
                        "type": "array",
                        "items": {
                          "description": "PCRE regex to allow quoted string values, even if required: only-when-needed is set.",
                          "type": "string",
                          "format": "regex"
                        },
                        "default": []
                      }
                    }
                  }
                }
              ],
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        },
        "trailing-spaces": {
          "title": "Trailing Spaces",
          "description": "Use this rule to forbid trailing spaces at the end of lines.",
          "default": "enable",
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "unevaluatedProperties": false
            }
          ]
        },
        "truthy": {
          "title": "Truthy",
          "description": "Use this rule to forbid non-explicitly typed truthy values other than allowed ones (by default: true and false), for example YES or off.\n\nThis can be useful to prevent surprises from YAML parsers transforming [yes, FALSE, Off] into [true, false, false] or {y: 1, yes: 2, on: 3, true: 4, True: 5} into {y: 1, true: 5}.\n\nDepending on the YAML specification version used by the YAML document, the list of truthy values can differ. In YAML 1.2, only capitalized / uppercased combinations of true and false are considered truthy, whereas in YAML 1.1 combinations of yes, no, on and off are too. To make the YAML specification version explicit in a YAML document, a %YAML 1.2 directive can be used (see example below).",
          "default": {
            "level": "warning"
          },
          "oneOf": [
            {
              "$ref": "#/$defs/toggle"
            },
            {
              "$ref": "#/$defs/rule",
              "properties": {
                "allowed-values": {
                  "title": "Allowed Values",
                  "description": "allowed-values defines the list of truthy values which will be ignored during linting.",
                  "type": "array",
                  "items": {
                    "title": "Allowed Value",
                    "description": "A truthy value which will be ignored (allowed) during linting.",
                    "enum": [
                      "TRUE",
                      "True",
                      "true",
                      "FALSE",
                      "False",
                      "false",
                      "YES",
                      "Yes",
                      "yes",
                      "NO",
                      "No",
                      "no",
                      "ON",
                      "On",
                      "on",
                      "OFF",
                      "Off",
                      "off"
                    ]
                  },
                  "uniqueItems": true,
                  "default": [
                    "true",
                    "false"
                  ]
                },
                "check-keys": {
                  "title": "Check Keys",
                  "description": "check-keys disables verification for keys in mappings. By default, truthy rule applies to both keys and values. Set this option to false to prevent this.",
                  "type": "boolean",
                  "default": true
                }
              },
              "unevaluatedProperties": false,
              "type": "object"
            }
          ]
        }
      },
      "unevaluatedProperties": false
    }
  },
  "$defs": {
    "ignorable": {
      "type": "object",
      "properties": {
        "ignore": {
          "type": [
            "string",
            "array"
          ],
          "items": {
            "type": "string"
          }
        },
        "ignore-from-file": {
          "type": [
            "string",
            "array"
          ],
          "items": {
            "type": "string"
          }
        }
      },
      "not": {
        "required": [
          "ignore",
          "ignore-from-file"
        ]
      }
    },
    "rule": {
      "$ref": "#/$defs/ignorable",
      "type": "object",
      "properties": {
        "level": {
          "enum": [
            "error",
            "warning"
          ],
          "default": "error"
        }
      }
    },
    "toggle": {
      "oneOf": [
        {
          "enum": [
            "enable",
            "disable"
          ]
        },
        {
          "type": "boolean"
        }
      ]
    }
  },
  "unevaluatedProperties": false,
  "$comment": "https://yamllint.readthedocs.io/en/stable/configuration.html",
  "$ref": "#/$defs/ignorable"
}