schema.json

{
  "title": "JSON schema for the TranslitRule file",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "anyOf": [
    {
      "$ref": "#/definitions/TranslitRule"
    },
    {
      "items": {
        "$ref": "#/definitions/TranslitRulePhase"
      },
      "type": "array"
    },
    {
      "items": {
        "$ref": "#/definitions/TranslitRuleItem"
      },
      "type": "array"
    }
  ],
  "definitions": {
    "PostRulesStrategy": {
      "description": "Post rules looping and matching strategy.",
      "enum": [
        "startMatch",
        "whileMatch"
      ],
      "type": "string"
    },
    "TplVar": {
      "additionalProperties": {
        "type": "string",
        "minLength": 1
      },
      "description": "Template variables definition.",
      "type": "object",
      "propertyNames": {
        "pattern": "^#[A-Za-z][A-Za-z0-9_]*$"
      }
    },
    "TranslitRule": {
      "additionalProperties": false,
      "description": "Transliterate rule.",
      "properties": {
        "$schema": {
          "description": "Link to schema file.",
          "type": "string"
        },
        "description": {
          "description": "Description for the rule.",
          "type": "string"
        },
        "phases": {
          "description": "Transliterate rule phases.",
          "items": {
            "$ref": "#/definitions/TranslitRulePhase"
          },
          "minItems": 1,
          "type": "array"
        },
        "tplVar": {
          "$ref": "#/definitions/TplVar",
          "description": "Global template variables definition."
        },
        "version": {
          "description": "The version for the rule.",
          "type": "string"
        }
      },
      "type": "object",
      "required": [
        "phases"
      ]
    },
    "TranslitRuleItem": {
      "additionalProperties": false,
      "description": "Transliterate rule item.",
      "properties": {
        "description": {
          "description": "Description for the rule item.",
          "type": "string"
        },
        "from": {
          "description": "Regular expression pattern for input string searching.",
          "minLength": 1,
          "type": "string"
        },
        "hasLeft": {
          "description": "Set `true` to replace only if there was any converted left part characters, set `false` for reverse purpose checking.",
          "type": "boolean"
        },
        "left": {
          "description": "Regular expression pattern for checking converted left part string.",
          "type": "string"
        },
        "minLength": {
          "description": "Minimum input string length matching for quick checking purpose.",
          "minimum": 1,
          "type": "integer"
        },
        "postRules": {
          "description": "Sub-rule items to be processed after replaced.",
          "items": {
            "$ref": "#/definitions/TranslitSubRuleItem"
          },
          "minItems": 1,
          "type": "array"
        },
        "postRulesRef": {
          "description": "Set the name defined in `postRulesDef` for referencing post rules.",
          "type": "string"
        },
        "postRulesStart": {
          "additionalProperties": {
            "type": "number"
          },
          "description": "The key value pair of `orGroup` and `start` index for `postRules` items.",
          "type": "object"
        },
        "postRulesStrategy": {
          "$ref": "#/definitions/PostRulesStrategy",
          "description": "Post rules looping and matching strategy. Default is `startMatch`."
        },
        "quickTests": {
          "description": "Array of input string character and index position matching for quick checking purpose.",
          "items": {
            "additionalItems": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "number"
                }
              ]
            },
            "items": [
              {
                "type": "string",
                "description": "Character for quick test checking.",
                "minLength": 1
              },
              {
                "type": "integer",
                "description": "Index of the character for quick test checking.",
                "minimum": 0
              }
            ],
            "minItems": 2,
            "type": "array"
          },
          "type": "array"
        },
        "right": {
          "description": "Regular expression pattern for checking right part string after input string matching.",
          "type": "string"
        },
        "skip": {
          "$ref": "#/definitions/WhenOrSkipOptions",
          "description": "Apply the rule only if `skip` options and user options are met."
        },
        "to": {
          "description": "The value to replace the matched string.",
          "type": "string"
        },
        "when": {
          "$ref": "#/definitions/WhenOrSkipOptions",
          "description": "Apply the rule only if `when` options and user options are met."
        }
      },
      "type": "object",
      "required": [
        "from"
      ]
    },
    "TranslitRulePhase": {
      "additionalProperties": false,
      "description": "Transliterate rule phase.",
      "properties": {
        "description": {
          "description": "Description for the rule phase.",
          "type": "string"
        },
        "postRulesDef": {
          "additionalProperties": {
            "items": {
              "$ref": "#/definitions/TranslitSubRuleItem"
            },
            "type": "array"
          },
          "description": "Post rules definitions to be used with `postRulesRef`.",
          "type": "object"
        },
        "rules": {
          "description": "Array of Transliterate rule items.",
          "items": {
            "$ref": "#/definitions/TranslitRuleItem"
          },
          "minItems": 1,
          "type": "array"
        },
        "skip": {
          "$ref": "#/definitions/WhenOrSkipOptions",
          "description": "Apply the phase only if `skip` options and user options are met."
        },
        "tplSeq": {
          "additionalProperties": {
            "items": {
              "additionalItems": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "type": "string"
                  },
                  {
                    "type": "number"
                  }
                ]
              },
              "items": [
                {
                  "type": "string",
                  "description": "'from' start character for sequence loop.",
                  "minLength": 1
                },
                {
                  "type": "string",
                  "description": "'to' start character for sequence loop."
                },
                {
                  "type": "integer",
                  "description": "Sequence loop count.",
                  "minimum": 1
                }
              ],
              "minItems": 3,
              "type": "array"
            },
            "type": "array",
            "minItems": 1
          },
          "description": "Template loop/sequence variables definition.",
          "type": "object"
        },
        "tplVar": {
          "$ref": "#/definitions/TplVar",
          "description": "Phase level template variables definition."
        },
        "when": {
          "$ref": "#/definitions/WhenOrSkipOptions",
          "description": "Apply the phase only if `when` options and user options are met."
        }
      },
      "type": "object",
      "required": [
        "rules"
      ]
    },
    "TranslitSubRuleItem": {
      "additionalProperties": false,
      "description": "Transliterate sub-rule item.",
      "properties": {
        "description": {
          "description": "Description for the rule item.",
          "type": "string"
        },
        "from": {
          "description": "Regular expression pattern for input string searching.",
          "minLength": 1,
          "type": "string"
        },
        "orGroup": {
          "description": "Group code for grouping `or` items.",
          "type": "string"
        },
        "skip": {
          "$ref": "#/definitions/WhenOrSkipOptions",
          "description": "Apply the rule only if `skip` options and user options are met."
        },
        "start": {
          "description": "Start index for searching. Set `-1` for skipping the rule. It works only when `postRulesStrategy` is `startMatch`.",
          "minimum": -1,
          "type": "integer"
        },
        "to": {
          "description": "The value to replace the matched string.",
          "type": "string"
        },
        "when": {
          "$ref": "#/definitions/WhenOrSkipOptions",
          "description": "Apply the rule only if `when` options and user options are met."
        }
      },
      "type": "object",
      "required": [
        "from",
        "to"
      ]
    },
    "WhenOrSkipOptions": {
      "additionalProperties": {
        "type": [
          "string",
          "boolean"
        ]
      },
      "description": "The `when` or `skip` options to apply only if it equals with user input option.",
      "type": "object"
    }
  }
}