cspell.schema.json

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false,
  "definitions": {
    "CacheSettings": {
      "additionalProperties": false,
      "properties": {
        "cacheLocation": {
          "$ref": "#/definitions/FSPathResolvable",
          "description": "Path to the cache location. Can be a file or a directory. If none specified `.cspellcache` will be used. Relative paths are relative to the config file in which it is defined.\n\nA prefix of `${cwd}` is replaced with the current working directory."
        },
        "cacheStrategy": {
          "$ref": "#/definitions/CacheStrategy",
          "default": "metadata",
          "description": "Strategy to use for detecting changed files, default: metadata"
        },
        "useCache": {
          "default": false,
          "description": "Store the results of processed files in order to only operate on the changed ones.",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "CacheStrategy": {
      "description": "The Strategy to use to detect if a file has changed.\n- `metadata` - uses the file system timestamp and size to detect changes (fastest).\n- `content` - uses a hash of the file content to check file changes (slower - more accurate).",
      "enum": [
        "metadata",
        "content"
      ],
      "type": "string"
    },
    "CustomDictionaryPath": {
      "description": "A File System Path to a dictionary file.",
      "pattern": "^.*\\.txt$",
      "type": "string"
    },
    "CustomDictionaryScope": {
      "description": "Specifies the scope of a dictionary.",
      "enum": [
        "user",
        "workspace",
        "folder"
      ],
      "type": "string"
    },
    "DictionaryDefinition": {
      "anyOf": [
        {
          "$ref": "#/definitions/DictionaryDefinitionPreferred"
        },
        {
          "$ref": "#/definitions/DictionaryDefinitionCustom"
        },
        {
          "$ref": "#/definitions/DictionaryDefinitionAlternate"
        }
      ]
    },
    "DictionaryDefinitionAlternate": {
      "additionalProperties": false,
      "deprecated": true,
      "deprecationMessage": "Use `DictionaryDefinitionPreferred` instead.",
      "description": "Only for legacy dictionary definitions.",
      "properties": {
        "description": {
          "description": "Optional description.",
          "type": "string"
        },
        "file": {
          "$ref": "#/definitions/DictionaryPath",
          "deprecated": true,
          "deprecationMessage": "Use `path` instead.",
          "description": "Path to the file, only for legacy dictionary definitions."
        },
        "name": {
          "$ref": "#/definitions/DictionaryId",
          "description": "This is the name of a dictionary.\n\nName Format:\n- Must contain at least 1 number or letter.\n- Spaces are allowed.\n- Leading and trailing space will be removed.\n- Names ARE case-sensitive.\n- Must not contain `*`, `!`, `;`, `,`, `{`, `}`, `[`, `]`, `~`."
        },
        "noSuggest": {
          "description": "Indicate that suggestions should not come from this dictionary. Words in this dictionary are considered correct, but will not be used when making spell correction suggestions.\n\nNote: if a word is suggested by another dictionary, but found in this dictionary, it will be removed from the set of possible suggestions.",
          "type": "boolean"
        },
        "repMap": {
          "$ref": "#/definitions/ReplaceMap",
          "description": "Replacement pairs."
        },
        "type": {
          "$ref": "#/definitions/DictionaryFileTypes",
          "default": "S",
          "description": "Type of file: S - single word per line, W - each line can contain one or more words separated by space, C - each line is treated like code (Camel Case is allowed). Default is S. C is the slowest to load due to the need to split each line based upon code splitting rules."
        },
        "useCompounds": {
          "description": "Use Compounds.",
          "type": "boolean"
        }
      },
      "required": [
        "file",
        "name"
      ],
      "type": "object"
    },
    "DictionaryDefinitionCustom": {
      "additionalProperties": false,
      "description": "For Defining Custom dictionaries. They are generally scoped to a `user`, `workspace`, or `folder`. When `addWords` is true, indicates that the spell checker can add words to the file. Note: only plain text files with one word per line are supported at this moment.",
      "properties": {
        "addWords": {
          "description": "When `true`, let's the spell checker know that words can be added to this dictionary.",
          "type": "boolean"
        },
        "description": {
          "description": "Optional description.",
          "type": "string"
        },
        "name": {
          "$ref": "#/definitions/DictionaryId",
          "description": "This is the name of a dictionary.\n\nName Format:\n- Must contain at least 1 number or letter.\n- Spaces are allowed.\n- Leading and trailing space will be removed.\n- Names ARE case-sensitive.\n- Must not contain `*`, `!`, `;`, `,`, `{`, `}`, `[`, `]`, `~`."
        },
        "noSuggest": {
          "description": "Indicate that suggestions should not come from this dictionary. Words in this dictionary are considered correct, but will not be used when making spell correction suggestions.\n\nNote: if a word is suggested by another dictionary, but found in this dictionary, it will be removed from the set of possible suggestions.",
          "type": "boolean"
        },
        "path": {
          "$ref": "#/definitions/CustomDictionaryPath",
          "description": "Path to custom dictionary text file."
        },
        "repMap": {
          "$ref": "#/definitions/ReplaceMap",
          "description": "Replacement pairs."
        },
        "scope": {
          "anyOf": [
            {
              "$ref": "#/definitions/CustomDictionaryScope"
            },
            {
              "items": {
                "$ref": "#/definitions/CustomDictionaryScope"
              },
              "type": "array"
            }
          ],
          "description": "Defines the scope for when words will be added to the dictionary. Scope values: `user`, `workspace`, `folder`."
        },
        "type": {
          "$ref": "#/definitions/DictionaryFileTypes",
          "default": "S",
          "description": "Type of file: S - single word per line, W - each line can contain one or more words separated by space, C - each line is treated like code (Camel Case is allowed). Default is S. C is the slowest to load due to the need to split each line based upon code splitting rules."
        },
        "useCompounds": {
          "description": "Use Compounds.",
          "type": "boolean"
        }
      },
      "required": [
        "addWords",
        "name",
        "path"
      ],
      "type": "object"
    },
    "DictionaryDefinitionPreferred": {
      "additionalProperties": false,
      "properties": {
        "description": {
          "description": "Optional description.",
          "type": "string"
        },
        "name": {
          "$ref": "#/definitions/DictionaryId",
          "description": "This is the name of a dictionary.\n\nName Format:\n- Must contain at least 1 number or letter.\n- Spaces are allowed.\n- Leading and trailing space will be removed.\n- Names ARE case-sensitive.\n- Must not contain `*`, `!`, `;`, `,`, `{`, `}`, `[`, `]`, `~`."
        },
        "noSuggest": {
          "description": "Indicate that suggestions should not come from this dictionary. Words in this dictionary are considered correct, but will not be used when making spell correction suggestions.\n\nNote: if a word is suggested by another dictionary, but found in this dictionary, it will be removed from the set of possible suggestions.",
          "type": "boolean"
        },
        "path": {
          "$ref": "#/definitions/DictionaryPath",
          "description": "Path to the file."
        },
        "repMap": {
          "$ref": "#/definitions/ReplaceMap",
          "description": "Replacement pairs."
        },
        "type": {
          "$ref": "#/definitions/DictionaryFileTypes",
          "default": "S",
          "description": "Type of file: S - single word per line, W - each line can contain one or more words separated by space, C - each line is treated like code (Camel Case is allowed). Default is S. C is the slowest to load due to the need to split each line based upon code splitting rules."
        },
        "useCompounds": {
          "description": "Use Compounds.",
          "type": "boolean"
        }
      },
      "required": [
        "name",
        "path"
      ],
      "type": "object"
    },
    "DictionaryFileTypes": {
      "enum": [
        "S",
        "W",
        "C",
        "T"
      ],
      "type": "string"
    },
    "DictionaryId": {
      "description": "This is the name of a dictionary.\n\nName Format:\n- Must contain at least 1 number or letter.\n- Spaces are allowed.\n- Leading and trailing space will be removed.\n- Names ARE case-sensitive.\n- Must not contain `*`, `!`, `;`, `,`, `{`, `}`, `[`, `]`, `~`.",
      "pattern": "^(?=[^!*,;{}[\\]~\\n]+$)(?=(.*\\w)).+$",
      "type": "string"
    },
    "DictionaryNegRef": {
      "description": "This a negative reference to a named dictionary.\n\nIt is used to exclude or include a dictionary by name.\n\nThe reference starts with 1 or more `!`.\n- `!<dictionary_name>` - Used to exclude the dictionary matching `<dictionary_name>`.\n- `!!<dictionary_name>` - Used to re-include a dictionary matching `<dictionary_name>`.    Overrides `!<dictionary_name>`.\n- `!!!<dictionary_name>` - Used to exclude a dictionary matching `<dictionary_name>`.    Overrides `!!<dictionary_name>`.",
      "pattern": "^(?=!+[^!*,;{}[\\]~\\n]+$)(?=(.*\\w)).+$",
      "type": "string"
    },
    "DictionaryPath": {
      "description": "A File System Path to a dictionary file.",
      "pattern": "^.*\\.(?:txt|trie)(?:\\.gz)?$",
      "type": "string"
    },
    "DictionaryRef": {
      "$ref": "#/definitions/DictionaryId",
      "description": "This a reference to a named dictionary. It is expected to match the name of a dictionary."
    },
    "DictionaryReference": {
      "anyOf": [
        {
          "$ref": "#/definitions/DictionaryRef"
        },
        {
          "$ref": "#/definitions/DictionaryNegRef"
        }
      ],
      "description": "Reference to a dictionary by name. One of:\n-  {@link  DictionaryRef } \n-  {@link  DictionaryNegRef }"
    },
    "FSPathResolvable": {
      "$ref": "#/definitions/FsPath",
      "description": "A File System Path.\n\nSpecial Properties:\n- `${cwd}` prefix - will be replaced with the current working directory.\n- Relative paths are relative to the configuration file."
    },
    "FsPath": {
      "description": "A File System Path. Relative paths are relative to the configuration file.",
      "type": "string"
    },
    "Glob": {
      "$ref": "#/definitions/SimpleGlob",
      "description": "These are glob expressions."
    },
    "LanguageId": {
      "anyOf": [
        {
          "$ref": "#/definitions/LanguageIdSingle"
        },
        {
          "$ref": "#/definitions/LanguageIdMultiple"
        },
        {
          "$ref": "#/definitions/LanguageIdMultipleNeg"
        }
      ]
    },
    "LanguageIdMultiple": {
      "description": "This can be 'typescript,cpp,json,literal haskell', etc.",
      "pattern": "^([-\\w_\\s]+)(,[-\\w_\\s]+)*$",
      "type": "string"
    },
    "LanguageIdMultipleNeg": {
      "description": "This can be 'typescript,cpp,json,literal haskell', etc.",
      "pattern": "^(![-\\w_\\s]+)(,![-\\w_\\s]+)*$",
      "type": "string"
    },
    "LanguageIdSingle": {
      "description": "This can be '*', 'typescript', 'cpp', 'json', etc.",
      "pattern": "^(!?[-\\w_\\s]+)|(\\*)$",
      "type": "string"
    },
    "LanguageSetting": {
      "additionalProperties": false,
      "properties": {
        "allowCompoundWords": {
          "default": false,
          "description": "True to enable compound word checking.",
          "type": "boolean"
        },
        "caseSensitive": {
          "default": false,
          "description": "Determines if words must match case and accent rules.\n\n- `false` - Case is ignored and accents can be missing on the entire word.   Incorrect accents or partially missing accents will be marked as incorrect.\n- `true` - Case and accents are enforced.",
          "type": "boolean"
        },
        "description": {
          "description": "Optional description of configuration.",
          "type": "string"
        },
        "dictionaries": {
          "description": "Optional list of dictionaries to use. Each entry should match the name of the dictionary. To remove a dictionary from the list add `!` before the name. i.e. `!typescript` will turn off the dictionary with the name `typescript`.",
          "items": {
            "$ref": "#/definitions/DictionaryReference"
          },
          "type": "array"
        },
        "dictionaryDefinitions": {
          "description": "Define additional available dictionaries.",
          "items": {
            "$ref": "#/definitions/DictionaryDefinition"
          },
          "type": "array"
        },
        "enabled": {
          "default": true,
          "description": "Is the spell checker enabled.",
          "type": "boolean"
        },
        "flagWords": {
          "description": "List of words to always be considered incorrect.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "id": {
          "description": "Optional identifier.",
          "type": "string"
        },
        "ignoreRegExpList": {
          "$ref": "#/definitions/RegExpPatternList",
          "description": "List of RegExp patterns or Pattern names to exclude from spell checking.\n\nExample: [\"href\"] - to exclude html href."
        },
        "ignoreWords": {
          "description": "List of words to be ignored. An Ignored word will not show up as an error even if it is also in the `flagWords`.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "includeRegExpList": {
          "$ref": "#/definitions/RegExpPatternList",
          "description": "List of RegExp patterns or defined Pattern names to define the text to be included for spell checking. If includeRegExpList is defined, ONLY, text matching the included patterns will be checked."
        },
        "languageId": {
          "anyOf": [
            {
              "$ref": "#/definitions/LanguageId"
            },
            {
              "items": {
                "$ref": "#/definitions/LanguageIdSingle"
              },
              "type": "array"
            }
          ],
          "description": "The language id.  Ex: \"typescript\", \"html\", or \"php\".  \"*\" -- will match all languages."
        },
        "local": {
          "anyOf": [
            {
              "$ref": "#/definitions/LocaleId"
            },
            {
              "items": {
                "$ref": "#/definitions/LocaleId"
              },
              "type": "array"
            }
          ],
          "deprecated": true,
          "deprecationMessage": "Use `locale` instead.",
          "description": "Deprecated - The locale filter, matches against the language. This can be a comma separated list. \"*\" will match all locales."
        },
        "locale": {
          "anyOf": [
            {
              "$ref": "#/definitions/LocaleId"
            },
            {
              "items": {
                "$ref": "#/definitions/LocaleId"
              },
              "type": "array"
            }
          ],
          "description": "The locale filter, matches against the language. This can be a comma separated list. \"*\" will match all locales."
        },
        "name": {
          "description": "Optional name of configuration.",
          "type": "string"
        },
        "noSuggestDictionaries": {
          "description": "Optional list of dictionaries that will not be used for suggestions. Words in these dictionaries are considered correct, but will not be used when making spell correction suggestions.\n\nNote: if a word is suggested by another dictionary, but found in one of these dictionaries, it will be removed from the set of possible suggestions.",
          "items": {
            "$ref": "#/definitions/DictionaryReference"
          },
          "type": "array"
        },
        "patterns": {
          "description": "Defines a list of patterns that can be used in ignoreRegExpList and includeRegExpList.",
          "items": {
            "$ref": "#/definitions/RegExpPatternDefinition"
          },
          "type": "array"
        },
        "words": {
          "description": "List of words to be always considered correct.",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "languageId"
      ],
      "type": "object"
    },
    "LocaleId": {
      "description": "This is a written language locale like: 'en', 'en-GB', 'fr', 'es', 'de', etc.",
      "type": "string"
    },
    "OverrideSettings": {
      "additionalProperties": false,
      "properties": {
        "allowCompoundWords": {
          "default": false,
          "description": "True to enable compound word checking.",
          "type": "boolean"
        },
        "caseSensitive": {
          "default": false,
          "description": "Determines if words must match case and accent rules.\n\n- `false` - Case is ignored and accents can be missing on the entire word.   Incorrect accents or partially missing accents will be marked as incorrect.\n- `true` - Case and accents are enforced.",
          "type": "boolean"
        },
        "description": {
          "description": "Optional description of configuration.",
          "type": "string"
        },
        "dictionaries": {
          "description": "Optional list of dictionaries to use. Each entry should match the name of the dictionary. To remove a dictionary from the list add `!` before the name. i.e. `!typescript` will turn off the dictionary with the name `typescript`.",
          "items": {
            "$ref": "#/definitions/DictionaryReference"
          },
          "type": "array"
        },
        "dictionaryDefinitions": {
          "description": "Define additional available dictionaries.",
          "items": {
            "$ref": "#/definitions/DictionaryDefinition"
          },
          "type": "array"
        },
        "enableFiletypes": {
          "items": {
            "$ref": "#/definitions/LanguageIdSingle"
          },
          "markdownDescription": "Enable / Disable checking file types (languageIds).\nThese are in additional to the file types specified by `cSpell.enabledLanguageIds`.\nTo disable a language, prefix with `!` as in `!json`,\n\nExample:\n```\njsonc       // enable checking for jsonc\n!json       // disable checking for json\nkotlin      // enable checking for kotlin\n```",
          "scope": "resource",
          "title": "File Types to Check",
          "type": "array",
          "uniqueItems": true
        },
        "enabled": {
          "default": true,
          "description": "Is the spell checker enabled.",
          "type": "boolean"
        },
        "enabledLanguageIds": {
          "description": "languageIds for the files to spell check.",
          "items": {
            "$ref": "#/definitions/LanguageIdSingle"
          },
          "type": "array"
        },
        "filename": {
          "anyOf": [
            {
              "$ref": "#/definitions/Glob"
            },
            {
              "items": {
                "$ref": "#/definitions/Glob"
              },
              "type": "array"
            }
          ],
          "description": "Glob pattern or patterns to match against."
        },
        "flagWords": {
          "description": "List of words to always be considered incorrect.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "id": {
          "description": "Optional identifier.",
          "type": "string"
        },
        "ignoreRegExpList": {
          "$ref": "#/definitions/RegExpPatternList",
          "description": "List of RegExp patterns or Pattern names to exclude from spell checking.\n\nExample: [\"href\"] - to exclude html href."
        },
        "ignoreWords": {
          "description": "List of words to be ignored. An Ignored word will not show up as an error even if it is also in the `flagWords`.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "includeRegExpList": {
          "$ref": "#/definitions/RegExpPatternList",
          "description": "List of RegExp patterns or defined Pattern names to define the text to be included for spell checking. If includeRegExpList is defined, ONLY, text matching the included patterns will be checked."
        },
        "language": {
          "$ref": "#/definitions/LocaleId",
          "description": "Sets the locale."
        },
        "languageId": {
          "$ref": "#/definitions/LanguageId",
          "description": "Sets the programming language id."
        },
        "languageSettings": {
          "description": "Additional settings for individual languages.",
          "items": {
            "$ref": "#/definitions/LanguageSetting"
          },
          "type": "array"
        },
        "maxDuplicateProblems": {
          "default": 5,
          "description": "The maximum number of times the same word can be flagged as an error in a file.",
          "type": "number"
        },
        "maxNumberOfProblems": {
          "default": 100,
          "description": "The maximum number of problems to report in a file.",
          "type": "number"
        },
        "minWordLength": {
          "default": 4,
          "description": "The minimum length of a word before checking it against a dictionary.",
          "type": "number"
        },
        "name": {
          "description": "Optional name of configuration.",
          "type": "string"
        },
        "noSuggestDictionaries": {
          "description": "Optional list of dictionaries that will not be used for suggestions. Words in these dictionaries are considered correct, but will not be used when making spell correction suggestions.\n\nNote: if a word is suggested by another dictionary, but found in one of these dictionaries, it will be removed from the set of possible suggestions.",
          "items": {
            "$ref": "#/definitions/DictionaryReference"
          },
          "type": "array"
        },
        "numSuggestions": {
          "default": 10,
          "description": "Number of suggestions to make.",
          "type": "number"
        },
        "patterns": {
          "description": "Defines a list of patterns that can be used in ignoreRegExpList and includeRegExpList.",
          "items": {
            "$ref": "#/definitions/RegExpPatternDefinition"
          },
          "type": "array"
        },
        "pnpFiles": {
          "default": [
            ".pnp.js",
            ".pnp.cjs"
          ],
          "description": "The PnP files to search for. Note: `.mjs` files are not currently supported.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "suggestionNumChanges": {
          "default": 3,
          "description": "The maximum number of changes allowed on a word to be considered a suggestions.\n\nFor example, appending an `s` onto `example` -> `examples` is considered 1 change.\n\nRange: between 1 and 5.",
          "type": "number"
        },
        "suggestionsTimeout": {
          "default": 500,
          "description": "The maximum amount of time in milliseconds to generate suggestions for a word.",
          "type": "number"
        },
        "usePnP": {
          "default": false,
          "description": "Packages managers like Yarn 2 use a `.pnp.cjs` file to assist in loading packages stored in the repository.\n\nWhen true, the spell checker will search up the directory structure for the existence of a PnP file and load it.",
          "type": "boolean"
        },
        "words": {
          "description": "List of words to be always considered correct.",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "filename"
      ],
      "type": "object"
    },
    "Pattern": {
      "type": "string"
    },
    "PatternId": {
      "description": "This matches the name in a pattern definition.",
      "type": "string"
    },
    "PatternRef": {
      "anyOf": [
        {
          "$ref": "#/definitions/Pattern"
        },
        {
          "$ref": "#/definitions/PatternId"
        },
        {
          "$ref": "#/definitions/PredefinedPatterns"
        }
      ],
      "description": "A PatternRef is a Pattern or PatternId."
    },
    "PredefinedPatterns": {
      "enum": [
        "Base64",
        "Base64MultiLine",
        "Base64SingleLine",
        "CStyleComment",
        "CStyleHexValue",
        "CSSHexValue",
        "CommitHash",
        "CommitHashLink",
        "Email",
        "EscapeCharacters",
        "HexValues",
        "href",
        "PhpHereDoc",
        "PublicKey",
        "RsaCert",
        "SshRsa",
        "SHA",
        "HashStrings",
        "SpellCheckerDisable",
        "SpellCheckerDisableBlock",
        "SpellCheckerDisableLine",
        "SpellCheckerDisableNext",
        "SpellCheckerIgnoreInDocSetting",
        "string",
        "UnicodeRef",
        "Urls",
        "UUID",
        "Everything"
      ],
      "type": "string"
    },
    "RegExpPatternDefinition": {
      "additionalProperties": false,
      "properties": {
        "description": {
          "description": "Description of the pattern.",
          "type": "string"
        },
        "name": {
          "$ref": "#/definitions/PatternId",
          "description": "Pattern name, used as an identifier in ignoreRegExpList and includeRegExpList. It is possible to redefine one of the predefined patterns to override its value."
        },
        "pattern": {
          "anyOf": [
            {
              "$ref": "#/definitions/Pattern"
            },
            {
              "items": {
                "$ref": "#/definitions/Pattern"
              },
              "type": "array"
            }
          ],
          "description": "RegExp pattern or array of RegExp patterns."
        }
      },
      "required": [
        "name",
        "pattern"
      ],
      "type": "object"
    },
    "RegExpPatternList": {
      "description": "A list of pattern names or regular expressions.",
      "items": {
        "$ref": "#/definitions/PatternRef"
      },
      "type": "array"
    },
    "ReplaceEntry": {
      "items": {
        "type": "string"
      },
      "maxItems": 2,
      "minItems": 2,
      "type": "array"
    },
    "ReplaceMap": {
      "items": {
        "$ref": "#/definitions/ReplaceEntry"
      },
      "type": "array"
    },
    "ReporterSettings": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "items": {
            "type": "string"
          },
          "maxItems": 1,
          "minItems": 1,
          "type": "array"
        },
        {
          "items": [
            {
              "type": "string"
            },
            {}
          ],
          "maxItems": 2,
          "minItems": 2,
          "type": "array"
        }
      ],
      "description": "Reporter name or reporter name + reporter config."
    },
    "SimpleGlob": {
      "description": "Simple Glob string, the root will be globRoot.",
      "type": "string"
    },
    "Version": {
      "anyOf": [
        {
          "$ref": "#/definitions/VersionLatest"
        },
        {
          "$ref": "#/definitions/VersionLegacy"
        }
      ]
    },
    "VersionLatest": {
      "const": "0.2",
      "description": "Configuration File Version.",
      "type": "string"
    },
    "VersionLegacy": {
      "const": "0.1",
      "deprecated": true,
      "deprecationMessage": "Use `0.2` instead.",
      "description": "Legacy Configuration File Versions.",
      "type": "string"
    }
  },
  "properties": {
    "$schema": {
      "type": "string"
    },
    "allowCompoundWords": {
      "default": false,
      "description": "True to enable compound word checking.",
      "type": "boolean"
    },
    "cache": {
      "$ref": "#/definitions/CacheSettings",
      "description": "Define cache settings."
    },
    "caseSensitive": {
      "default": false,
      "description": "Determines if words must match case and accent rules.\n\n- `false` - Case is ignored and accents can be missing on the entire word.   Incorrect accents or partially missing accents will be marked as incorrect.\n- `true` - Case and accents are enforced.",
      "type": "boolean"
    },
    "description": {
      "description": "Optional description of configuration.",
      "type": "string"
    },
    "dictionaries": {
      "description": "Optional list of dictionaries to use. Each entry should match the name of the dictionary. To remove a dictionary from the list add `!` before the name. i.e. `!typescript` will turn off the dictionary with the name `typescript`.",
      "items": {
        "$ref": "#/definitions/DictionaryReference"
      },
      "type": "array"
    },
    "dictionaryDefinitions": {
      "description": "Define additional available dictionaries.",
      "items": {
        "$ref": "#/definitions/DictionaryDefinition"
      },
      "type": "array"
    },
    "enableFiletypes": {
      "items": {
        "$ref": "#/definitions/LanguageIdSingle"
      },
      "markdownDescription": "Enable / Disable checking file types (languageIds).\nThese are in additional to the file types specified by `cSpell.enabledLanguageIds`.\nTo disable a language, prefix with `!` as in `!json`,\n\nExample:\n```\njsonc       // enable checking for jsonc\n!json       // disable checking for json\nkotlin      // enable checking for kotlin\n```",
      "scope": "resource",
      "title": "File Types to Check",
      "type": "array",
      "uniqueItems": true
    },
    "enableGlobDot": {
      "default": false,
      "description": "Enable scanning files and directories beginning with `.` (period). By default, CSpell does not scan `hidden` files.",
      "type": "boolean"
    },
    "enabled": {
      "default": true,
      "description": "Is the spell checker enabled.",
      "type": "boolean"
    },
    "enabledLanguageIds": {
      "description": "languageIds for the files to spell check.",
      "items": {
        "$ref": "#/definitions/LanguageIdSingle"
      },
      "type": "array"
    },
    "files": {
      "description": "Glob patterns of files to be checked. Glob patterns are relative to the `globRoot` of the configuration file that defines them.",
      "items": {
        "$ref": "#/definitions/Glob"
      },
      "type": "array"
    },
    "flagWords": {
      "description": "List of words to always be considered incorrect.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "gitignoreRoot": {
      "anyOf": [
        {
          "$ref": "#/definitions/FsPath"
        },
        {
          "items": {
            "$ref": "#/definitions/FsPath"
          },
          "type": "array"
        }
      ],
      "description": "Tells the spell checker to searching for `.gitignore` files when it reaches a matching root."
    },
    "globRoot": {
      "$ref": "#/definitions/FSPathResolvable",
      "description": "The root to use for glob patterns found in this configuration. Default: location of the configuration file.   For compatibility reasons, config files with version 0.1, the glob root will   default to be `${cwd}`.\n\nUse `globRoot` to define a different location. `globRoot` can be relative to the location of this configuration file. Defining globRoot, does not impact imported configurations.\n\nSpecial Values:\n- `${cwd}` - will be replaced with the current working directory.\n- `.` - will be the location of the containing configuration file."
    },
    "id": {
      "description": "Optional identifier.",
      "type": "string"
    },
    "ignorePaths": {
      "description": "Glob patterns of files to be ignored. Glob patterns are relative to the `globRoot` of the configuration file that defines them.",
      "items": {
        "$ref": "#/definitions/Glob"
      },
      "type": "array"
    },
    "ignoreRegExpList": {
      "$ref": "#/definitions/RegExpPatternList",
      "description": "List of RegExp patterns or Pattern names to exclude from spell checking.\n\nExample: [\"href\"] - to exclude html href."
    },
    "ignoreWords": {
      "description": "List of words to be ignored. An Ignored word will not show up as an error even if it is also in the `flagWords`.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "import": {
      "anyOf": [
        {
          "$ref": "#/definitions/FsPath"
        },
        {
          "items": {
            "$ref": "#/definitions/FsPath"
          },
          "type": "array"
        }
      ],
      "description": "Other settings files to be included."
    },
    "includeRegExpList": {
      "$ref": "#/definitions/RegExpPatternList",
      "description": "List of RegExp patterns or defined Pattern names to define the text to be included for spell checking. If includeRegExpList is defined, ONLY, text matching the included patterns will be checked."
    },
    "language": {
      "$ref": "#/definitions/LocaleId",
      "default": "en",
      "description": "Current active spelling language.\n\nExample: \"en-GB\" for British English.\n\nExample: \"en,nl\" to enable both English and Dutch."
    },
    "languageId": {
      "$ref": "#/definitions/LanguageId",
      "description": "Forces the spell checker to assume a give language id. Used mainly as an Override."
    },
    "languageSettings": {
      "description": "Additional settings for individual languages.",
      "items": {
        "$ref": "#/definitions/LanguageSetting"
      },
      "type": "array"
    },
    "maxDuplicateProblems": {
      "default": 5,
      "description": "The maximum number of times the same word can be flagged as an error in a file.",
      "type": "number"
    },
    "maxNumberOfProblems": {
      "default": 100,
      "description": "The maximum number of problems to report in a file.",
      "type": "number"
    },
    "minWordLength": {
      "default": 4,
      "description": "The minimum length of a word before checking it against a dictionary.",
      "type": "number"
    },
    "name": {
      "description": "Optional name of configuration.",
      "type": "string"
    },
    "noConfigSearch": {
      "default": false,
      "description": "Prevents searching for local configuration when checking individual documents.",
      "type": "boolean"
    },
    "noSuggestDictionaries": {
      "description": "Optional list of dictionaries that will not be used for suggestions. Words in these dictionaries are considered correct, but will not be used when making spell correction suggestions.\n\nNote: if a word is suggested by another dictionary, but found in one of these dictionaries, it will be removed from the set of possible suggestions.",
      "items": {
        "$ref": "#/definitions/DictionaryReference"
      },
      "type": "array"
    },
    "numSuggestions": {
      "default": 10,
      "description": "Number of suggestions to make.",
      "type": "number"
    },
    "overrides": {
      "description": "Overrides to apply based upon the file path.",
      "items": {
        "$ref": "#/definitions/OverrideSettings"
      },
      "type": "array"
    },
    "patterns": {
      "description": "Defines a list of patterns that can be used in ignoreRegExpList and includeRegExpList.",
      "items": {
        "$ref": "#/definitions/RegExpPatternDefinition"
      },
      "type": "array"
    },
    "pnpFiles": {
      "default": [
        ".pnp.js",
        ".pnp.cjs"
      ],
      "description": "The PnP files to search for. Note: `.mjs` files are not currently supported.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "readonly": {
      "default": false,
      "description": "Indicate that the configuration file should not be modified. This is used to prevent tools like the VS Code Spell Checker from modifying the file to add words and other configuration.",
      "type": "boolean"
    },
    "reporters": {
      "description": "Custom reporters configuration.",
      "items": {
        "$ref": "#/definitions/ReporterSettings"
      },
      "type": "array"
    },
    "showStatus": {
      "deprecated": true,
      "description": "Show status.",
      "type": "boolean"
    },
    "spellCheckDelayMs": {
      "deprecated": true,
      "description": "Delay in ms after a document has changed before checking it for spelling errors.",
      "type": "number"
    },
    "suggestionNumChanges": {
      "default": 3,
      "description": "The maximum number of changes allowed on a word to be considered a suggestions.\n\nFor example, appending an `s` onto `example` -> `examples` is considered 1 change.\n\nRange: between 1 and 5.",
      "type": "number"
    },
    "suggestionsTimeout": {
      "default": 500,
      "description": "The maximum amount of time in milliseconds to generate suggestions for a word.",
      "type": "number"
    },
    "useGitignore": {
      "default": false,
      "description": "Tells the spell checker to load `.gitignore` files and skip files that match the globs in the `.gitignore` files found.",
      "type": "boolean"
    },
    "usePnP": {
      "default": false,
      "description": "Packages managers like Yarn 2 use a `.pnp.cjs` file to assist in loading packages stored in the repository.\n\nWhen true, the spell checker will search up the directory structure for the existence of a PnP file and load it.",
      "type": "boolean"
    },
    "userWords": {
      "description": "Words to add to global dictionary -- should only be in the user config file.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "version": {
      "$ref": "#/definitions/Version",
      "default": "0.2",
      "description": "Configuration format version of the settings file."
    },
    "words": {
      "description": "List of words to be always considered correct.",
      "items": {
        "type": "string"
      },
      "type": "array"
    }
  },
  "type": "object"
}