Hopi

{
  "type": "object",
  "required": [
    "start",
    "days"
  ],
  "properties": {
    "days": {
      "type": "integer",
      "maximum": 100000,
      "minimum": 0,
      "description": "Number of working days to move (0 to 100000)"
    },
    "start": {
      "type": "string",
      "format": "date",
      "description": "Start date in YYYY-MM-DD format"
    },
    "direction": {
      "enum": [
        "add",
        "sub"
      ],
      "type": "string",
      "default": "add",
      "description": "'add' to count forwards, 'sub' to count backwards (default 'add')"
    },
    "bankHolidays": {
      "type": "boolean",
      "default": true,
      "description": "Also skip England and Wales bank holidays, not just weekends (default true)"
    }
  }
}

{
  "type": "object",
  "required": [
    "dob"
  ],
  "properties": {
    "dob": {
      "type": "string",
      "format": "date",
      "description": "Date of birth in YYYY-MM-DD format"
    },
    "asOf": {
      "type": "string",
      "format": "date",
      "description": "Optional date to measure the age at, in YYYY-MM-DD format (defaults to today)"
    }
  }
}

{
  "type": "object",
  "required": [
    "abv",
    "ml"
  ],
  "properties": {
    "ml": {
      "type": "number",
      "description": "Volume of the drink in millilitres, e.g. 175 for a medium glass of wine",
      "exclusiveMinimum": 0
    },
    "abv": {
      "type": "number",
      "maximum": 100,
      "description": "Alcohol by volume as a percentage, e.g. 12 for 12% wine",
      "exclusiveMinimum": 0
    },
    "drinksPerWeek": {
      "type": "number",
      "description": "Optional number of these drinks per week, to work out a weekly units total",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to sort, one item per line"
    },
    "direction": {
      "enum": [
        "asc",
        "desc"
      ],
      "type": "string",
      "default": "asc",
      "description": "'asc' for A to Z (default), 'desc' for Z to A"
    },
    "caseInsensitive": {
      "type": "boolean",
      "default": false,
      "description": "Ignore letter case when sorting (default false)"
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "enum": [
        "deg",
        "rad",
        "grad",
        "turn"
      ],
      "type": "string",
      "description": "Unit to convert to"
    },
    "from": {
      "enum": [
        "deg",
        "rad",
        "grad",
        "turn"
      ],
      "type": "string",
      "description": "Unit to convert from"
    },
    "value": {
      "type": "number",
      "description": "The angle value to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "enum": [
        "sqm",
        "sqft",
        "sqyd",
        "acre",
        "ha",
        "sqkm",
        "sqmi"
      ],
      "type": "string",
      "description": "Unit to convert to"
    },
    "from": {
      "enum": [
        "sqm",
        "sqft",
        "sqyd",
        "acre",
        "ha",
        "sqkm",
        "sqmi"
      ],
      "type": "string",
      "description": "Unit to convert from"
    },
    "value": {
      "type": "number",
      "minimum": 0,
      "description": "The area value to convert"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "simplify"
          }
        }
      },
      "then": {
        "required": [
          "width",
          "height"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "solve"
          }
        }
      },
      "then": {
        "required": [
          "ratioW",
          "ratioH"
        ]
      }
    }
  ],
  "required": [
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "simplify",
        "solve"
      ],
      "type": "string",
      "description": "'simplify' a width and height, or 'solve' a missing side from a ratio"
    },
    "width": {
      "type": "number",
      "description": "Width in pixels or units (simplify mode, or the known side in solve mode)",
      "exclusiveMinimum": 0
    },
    "height": {
      "type": "number",
      "description": "Height in pixels or units (simplify mode, or the known side in solve mode)",
      "exclusiveMinimum": 0
    },
    "ratioH": {
      "type": "number",
      "description": "Ratio height part, e.g. 9 (solve mode)",
      "exclusiveMinimum": 0
    },
    "ratioW": {
      "type": "number",
      "description": "Ratio width part, e.g. 16 (solve mode)",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "numbers"
  ],
  "properties": {
    "numbers": {
      "type": "string",
      "minLength": 1,
      "description": "A list of numbers separated by spaces, commas, semicolons or new lines"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "mode": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "default": "encode",
      "description": "'encode' turns text into Base32, 'decode' turns Base32 back into text (default encode)"
    },
    "text": {
      "type": "string",
      "description": "The text to encode, or the Base32 string to decode"
    }
  }
}

{
  "type": "object",
  "required": [
    "text",
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "description": "'encode' text to Base64, or 'decode' Base64 back to text"
    },
    "text": {
      "type": "string",
      "description": "The text to encode, or the Base64 string to decode"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "count": {
      "type": "integer",
      "default": 1,
      "maximum": 100,
      "minimum": 1,
      "description": "How many cards to generate, 1 to 100 (default 1)"
    }
  }
}

{
  "type": "object",
  "required": [
    "address"
  ],
  "properties": {
    "address": {
      "type": "string",
      "description": "The Bitcoin address to validate"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "units": {
            "const": "metric"
          }
        }
      },
      "then": {
        "required": [
          "heightCm",
          "weightKg"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "units": {
            "const": "imperial"
          }
        }
      },
      "then": {
        "required": [
          "heightInches",
          "weightPounds"
        ]
      }
    }
  ],
  "required": [
    "units"
  ],
  "properties": {
    "units": {
      "enum": [
        "metric",
        "imperial"
      ],
      "type": "string",
      "description": "'metric' (cm and kg) or 'imperial' (inches and pounds)"
    },
    "heightCm": {
      "type": "number",
      "description": "Height in centimetres (metric)",
      "exclusiveMinimum": 0
    },
    "weightKg": {
      "type": "number",
      "description": "Weight in kilograms (metric)",
      "exclusiveMinimum": 0
    },
    "heightInches": {
      "type": "number",
      "description": "Total height in inches (imperial)",
      "exclusiveMinimum": 0
    },
    "weightPounds": {
      "type": "number",
      "description": "Weight in pounds (imperial)",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "text",
    "shift"
  ],
  "properties": {
    "mode": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "default": "encode",
      "description": "'encode' to apply the shift, 'decode' to reverse it (default encode)"
    },
    "text": {
      "type": "string",
      "description": "The text to transform"
    },
    "shift": {
      "type": "integer",
      "description": "How many places to shift each letter (e.g. 3, or 13 for ROT13)"
    }
  }
}

{
  "type": "object",
  "required": [
    "start",
    "end",
    "years"
  ],
  "properties": {
    "end": {
      "type": "number",
      "minimum": 0,
      "description": "Ending value"
    },
    "start": {
      "type": "number",
      "description": "Starting value (must be greater than zero)",
      "exclusiveMinimum": 0
    },
    "years": {
      "type": "number",
      "maximum": 200,
      "description": "Number of years over the period (may be a fraction)",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "amount",
    "unit"
  ],
  "properties": {
    "unit": {
      "enum": [
        "kcal",
        "kj"
      ],
      "type": "string",
      "description": "The unit of the amount: 'kcal' (kilocalories) or 'kj' (kilojoules)"
    },
    "amount": {
      "type": "number",
      "description": "The energy amount to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "text",
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "upper",
        "lower",
        "title",
        "sentence"
      ],
      "type": "string",
      "description": "The target case"
    },
    "text": {
      "type": "string",
      "description": "The text to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "catAge"
  ],
  "properties": {
    "catAge": {
      "type": "number",
      "maximum": 40,
      "minimum": 0,
      "description": "The cat's age in years (0 to 40)"
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "direction"
  ],
  "properties": {
    "value": {
      "type": "number",
      "description": "The temperature value to convert"
    },
    "direction": {
      "enum": [
        "c-to-f",
        "f-to-c"
      ],
      "type": "string",
      "description": "'c-to-f' converts Celsius to Fahrenheit, 'f-to-c' converts Fahrenheit to Celsius"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to measure"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "description": "The unknown text to identify and decode"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "direction": {
            "const": "cm-to-feet"
          }
        }
      },
      "then": {
        "required": [
          "cm"
        ]
      }
    }
  ],
  "required": [
    "direction"
  ],
  "properties": {
    "cm": {
      "type": "number",
      "minimum": 0,
      "description": "Centimetres (for cm-to-feet)"
    },
    "feet": {
      "type": "number",
      "minimum": 0,
      "description": "Feet (for feet-to-cm)"
    },
    "inches": {
      "type": "number",
      "minimum": 0,
      "description": "Inches (for feet-to-cm, optional)"
    },
    "direction": {
      "enum": [
        "cm-to-feet",
        "feet-to-cm"
      ],
      "type": "string",
      "description": "Which way to convert"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "cmyk_to_rgb"
          }
        }
      },
      "then": {
        "required": [
          "c",
          "m",
          "y",
          "k"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "rgb_to_cmyk"
          }
        }
      },
      "then": {
        "required": [
          "r",
          "g",
          "b"
        ]
      }
    }
  ],
  "required": [
    "mode"
  ],
  "properties": {
    "b": {
      "type": "integer",
      "maximum": 255,
      "minimum": 0,
      "description": "Blue 0 to 255 (for rgb_to_cmyk)"
    },
    "c": {
      "type": "number",
      "maximum": 100,
      "minimum": 0,
      "description": "Cyan 0 to 100 (for cmyk_to_rgb)"
    },
    "g": {
      "type": "integer",
      "maximum": 255,
      "minimum": 0,
      "description": "Green 0 to 255 (for rgb_to_cmyk)"
    },
    "k": {
      "type": "number",
      "maximum": 100,
      "minimum": 0,
      "description": "Key/black 0 to 100 (for cmyk_to_rgb)"
    },
    "m": {
      "type": "number",
      "maximum": 100,
      "minimum": 0,
      "description": "Magenta 0 to 100 (for cmyk_to_rgb)"
    },
    "r": {
      "type": "integer",
      "maximum": 255,
      "minimum": 0,
      "description": "Red 0 to 255 (for rgb_to_cmyk)"
    },
    "y": {
      "type": "number",
      "maximum": 100,
      "minimum": 0,
      "description": "Yellow 0 to 100 (for cmyk_to_rgb)"
    },
    "mode": {
      "enum": [
        "cmyk_to_rgb",
        "rgb_to_cmyk"
      ],
      "type": "string",
      "description": "Direction of conversion"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "count": {
      "type": "integer",
      "default": 1,
      "maximum": 10000,
      "minimum": 1,
      "description": "How many coins to flip, 1 to 10000 (default 1)"
    }
  }
}

{
  "type": "object",
  "required": [
    "hex"
  ],
  "properties": {
    "hex": {
      "type": "string",
      "pattern": "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$",
      "description": "Hex colour code, e.g. #DC143C or #F00"
    }
  }
}

{
  "type": "object",
  "required": [
    "hex"
  ],
  "properties": {
    "hex": {
      "type": "string",
      "pattern": "^#?[0-9a-fA-F]{6}$",
      "description": "Base colour as a six-digit hex code, e.g. #1F8A70"
    },
    "scheme": {
      "enum": [
        "analogous",
        "complementary",
        "triadic",
        "mixed"
      ],
      "type": "string",
      "default": "analogous",
      "description": "Colour scheme (default analogous)"
    }
  }
}

{
  "type": "object",
  "required": [
    "hex"
  ],
  "properties": {
    "hex": {
      "type": "string",
      "pattern": "^#?[0-9a-fA-F]{6}$",
      "description": "Six-digit hex colour code, e.g. #1F8A70"
    }
  }
}

{
  "type": "object",
  "required": [
    "hex"
  ],
  "properties": {
    "hex": {
      "type": "string",
      "pattern": "^#?[0-9a-fA-F]{6}$",
      "description": "Base colour as a six-digit hex code, e.g. #1F8A70"
    }
  }
}

{
  "type": "object",
  "required": [
    "items",
    "choose"
  ],
  "properties": {
    "items": {
      "type": "array",
      "maxItems": 10000,
      "minItems": 1,
      "description": "The list of items to choose from"
    },
    "choose": {
      "type": "integer",
      "minimum": 1,
      "description": "How many items to pick in each combination (r)"
    }
  }
}

{
  "type": "object",
  "required": [
    "rate",
    "years"
  ],
  "properties": {
    "rate": {
      "type": "number",
      "minimum": 0,
      "description": "Annual interest rate as a percentage"
    },
    "years": {
      "type": "number",
      "maximum": 100,
      "description": "Term in years (1 to 100)",
      "exclusiveMinimum": 0
    },
    "monthly": {
      "type": "number",
      "default": 0,
      "minimum": 0,
      "description": "Monthly contribution in GBP (default 0)"
    },
    "principal": {
      "type": "number",
      "default": 0,
      "minimum": 0,
      "description": "Starting deposit in GBP (default 0)"
    }
  }
}

{
  "type": "object",
  "required": [
    "foreground",
    "background"
  ],
  "properties": {
    "background": {
      "type": "string",
      "pattern": "^#?[0-9a-fA-F]{6}$",
      "description": "Background colour as a six-digit hex code, e.g. #FFFFFF"
    },
    "foreground": {
      "type": "string",
      "pattern": "^#?[0-9a-fA-F]{6}$",
      "description": "Text colour as a six-digit hex code, e.g. #767676"
    }
  }
}

{
  "type": "object",
  "required": [
    "expression"
  ],
  "properties": {
    "expression": {
      "type": "string",
      "minLength": 1,
      "description": "A five-field cron expression, for example '*/5 9-17 * * MON-FRI', or a shortcut like @daily"
    }
  }
}

{
  "type": "object",
  "required": [
    "buy",
    "quantity"
  ],
  "properties": {
    "buy": {
      "type": "number",
      "description": "Buy price per unit",
      "exclusiveMinimum": 0
    },
    "fee": {
      "type": "number",
      "default": 0,
      "minimum": 0,
      "description": "Fee percentage charged on each side (default 0, must be 0 to under 100)",
      "exclusiveMaximum": 100
    },
    "sell": {
      "type": "number",
      "minimum": 0,
      "description": "Sell price per unit (optional; omit to see breakeven only)"
    },
    "quantity": {
      "type": "number",
      "description": "Quantity of coin traded",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "colour1",
    "colour2"
  ],
  "properties": {
    "type": {
      "enum": [
        "linear",
        "radial"
      ],
      "type": "string",
      "default": "linear",
      "description": "Gradient type (default linear)"
    },
    "angle": {
      "type": "number",
      "default": 90,
      "maximum": 360,
      "minimum": 0,
      "description": "Angle in degrees for a linear gradient (default 90)"
    },
    "colour1": {
      "type": "string",
      "description": "First colour, e.g. #FF512F"
    },
    "colour2": {
      "type": "string",
      "description": "Second colour, e.g. #DD2476"
    }
  }
}

{
  "type": "object",
  "required": [
    "css"
  ],
  "properties": {
    "css": {
      "type": "string",
      "minLength": 1,
      "description": "The CSS source to minify"
    }
  }
}

{
  "type": "object",
  "required": [
    "csv"
  ],
  "properties": {
    "csv": {
      "type": "string",
      "minLength": 1,
      "description": "The CSV text to convert"
    },
    "firstRowHeaders": {
      "type": "boolean",
      "default": true,
      "description": "When true, the first row supplies the object keys; when false, every row becomes a plain array of strings (default true)"
    }
  }
}

{
  "type": "object",
  "required": [
    "cups",
    "ingredient"
  ],
  "properties": {
    "cups": {
      "type": "number",
      "minimum": 0,
      "description": "Number of US cups"
    },
    "ingredient": {
      "enum": [
        "flour",
        "caster",
        "brown",
        "butter",
        "cocoa",
        "oats",
        "rice",
        "icing"
      ],
      "type": "string",
      "description": "The ingredient"
    }
  }
}

{
  "type": "object",
  "required": [
    "amount",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "type": "string",
      "pattern": "^[A-Za-z]{3}$",
      "maxLength": 3,
      "minLength": 3,
      "description": "Currency to convert to, ISO 4217 code e.g. EUR"
    },
    "from": {
      "type": "string",
      "pattern": "^[A-Za-z]{3}$",
      "maxLength": 3,
      "minLength": 3,
      "description": "Currency to convert from, ISO 4217 code e.g. GBP"
    },
    "amount": {
      "type": "number",
      "description": "The amount to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "enum": [
        "B",
        "KB",
        "MB",
        "GB",
        "TB"
      ],
      "type": "string",
      "description": "Unit to convert to"
    },
    "from": {
      "enum": [
        "B",
        "KB",
        "MB",
        "GB",
        "TB"
      ],
      "type": "string",
      "description": "Unit to convert from"
    },
    "value": {
      "type": "number",
      "minimum": 0,
      "description": "The size value to convert"
    },
    "binary": {
      "type": "boolean",
      "default": false,
      "description": "Use binary units (1 KB = 1024 bytes) instead of decimal (default false)"
    }
  }
}

{
  "type": "object",
  "required": [
    "date",
    "amount"
  ],
  "properties": {
    "date": {
      "type": "string",
      "format": "date",
      "description": "Start date in YYYY-MM-DD format"
    },
    "unit": {
      "enum": [
        "days",
        "weeks",
        "months",
        "years"
      ],
      "type": "string",
      "default": "days",
      "description": "Unit to move by (default 'days')"
    },
    "amount": {
      "type": "integer",
      "maximum": 100000,
      "minimum": 0,
      "description": "How many units to move (0 to 100000)"
    },
    "direction": {
      "enum": [
        "add",
        "subtract"
      ],
      "type": "string",
      "default": "add",
      "description": "'add' to move forwards, 'subtract' to move backwards (default 'add')"
    }
  }
}

{
  "type": "object",
  "required": [
    "date"
  ],
  "properties": {
    "date": {
      "type": "string",
      "format": "date",
      "description": "The date in YYYY-MM-DD format"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "to_salary"
          }
        }
      },
      "then": {
        "required": [
          "dayRate"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "to_rate"
          }
        }
      },
      "then": {
        "required": [
          "salary"
        ]
      }
    }
  ],
  "required": [
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "to_salary",
        "to_rate"
      ],
      "type": "string",
      "description": "'to_salary' from a day rate, or 'to_rate' from a salary"
    },
    "salary": {
      "type": "number",
      "maximum": 100000000,
      "minimum": 0,
      "description": "Annual salary in GBP (required for to_rate)"
    },
    "dayRate": {
      "type": "number",
      "maximum": 1000000,
      "minimum": 0,
      "description": "Day rate in GBP (required for to_salary)"
    },
    "workingDays": {
      "type": "number",
      "default": 220,
      "maximum": 365,
      "minimum": 1,
      "description": "Billable working days per year, 1 to 365 (default 220)"
    }
  }
}

{
  "type": "object",
  "required": [
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "type": "string",
      "format": "date",
      "description": "End date in YYYY-MM-DD format"
    },
    "from": {
      "type": "string",
      "format": "date",
      "description": "Start date in YYYY-MM-DD format"
    },
    "inclusive": {
      "type": "boolean",
      "default": false,
      "description": "Count both end days rather than excluding the end day (default false)"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "from": {
      "type": "string",
      "format": "date",
      "description": "Optional date to count from, in YYYY-MM-DD format (defaults to today)"
    }
  }
}

{
  "type": "object",
  "required": [
    "buys"
  ],
  "properties": {
    "buys": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "amount",
          "price"
        ],
        "properties": {
          "price": {
            "type": "number",
            "description": "Price paid per unit on this buy",
            "exclusiveMinimum": 0
          },
          "amount": {
            "type": "number",
            "description": "Money spent on this buy",
            "exclusiveMinimum": 0
          }
        }
      },
      "minItems": 1,
      "description": "The list of buys"
    },
    "currentPrice": {
      "type": "number",
      "description": "Current price per unit (optional), to value the position now",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "sides": {
      "type": "integer",
      "default": 6,
      "minimum": 2,
      "description": "Number of sides on each die (default 6)"
    },
    "quantity": {
      "type": "integer",
      "default": 1,
      "maximum": 20,
      "minimum": 1,
      "description": "How many dice to roll, 1 to 20 (default 1)"
    }
  }
}

{
  "type": "object",
  "required": [
    "a",
    "b"
  ],
  "properties": {
    "a": {
      "type": "string",
      "description": "The original (left) text"
    },
    "b": {
      "type": "string",
      "description": "The changed (right) text"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "pct"
          }
        }
      },
      "then": {
        "required": [
          "percentOff"
        ],
        "properties": {
          "price": {
            "minimum": 0
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "fixed"
          }
        }
      },
      "then": {
        "required": [
          "amountOff"
        ],
        "properties": {
          "price": {
            "exclusiveMinimum": 0
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "find"
          }
        }
      },
      "then": {
        "required": [
          "finalPrice"
        ],
        "properties": {
          "price": {
            "exclusiveMinimum": 0
          }
        }
      }
    }
  ],
  "required": [
    "mode",
    "price"
  ],
  "properties": {
    "mode": {
      "enum": [
        "pct",
        "fixed",
        "find"
      ],
      "type": "string",
      "description": "'pct' percentage off, 'fixed' pound amount off, or 'find' the discount from two prices"
    },
    "price": {
      "type": "number",
      "description": "The original price (used in all modes)"
    },
    "amountOff": {
      "type": "number",
      "description": "Fixed pound amount off (mode 'fixed' only)"
    },
    "finalPrice": {
      "type": "number",
      "description": "The final price paid (mode 'find' only)"
    },
    "percentOff": {
      "type": "number",
      "description": "Discount percentage (mode 'pct' only)"
    }
  }
}

{
  "type": "object",
  "required": [
    "dogAge"
  ],
  "properties": {
    "size": {
      "enum": [
        "small",
        "medium",
        "large"
      ],
      "type": "string",
      "default": "medium",
      "description": "Dog size band (default 'medium')"
    },
    "dogAge": {
      "type": "number",
      "maximum": 30,
      "minimum": 0,
      "description": "The dog's age in years (0 to 30)"
    }
  }
}

{
  "type": "object",
  "required": [
    "size",
    "sizeUnit",
    "speed",
    "speedUnit"
  ],
  "properties": {
    "size": {
      "type": "number",
      "minimum": 0,
      "description": "File size value"
    },
    "speed": {
      "type": "number",
      "description": "Connection speed value",
      "exclusiveMinimum": 0
    },
    "sizeUnit": {
      "enum": [
        "MB",
        "GB",
        "TB"
      ],
      "type": "string",
      "description": "File size unit"
    },
    "speedUnit": {
      "enum": [
        "Mbps",
        "MBps",
        "Gbps"
      ],
      "type": "string",
      "description": "Speed unit: Mbps/Gbps are bits per second, MBps is megabytes per second"
    }
  }
}

{
  "type": "object",
  "required": [
    "lmp"
  ],
  "properties": {
    "lmp": {
      "type": "string",
      "format": "date",
      "description": "First day of the last menstrual period, ISO date 'YYYY-MM-DD'"
    },
    "cycleLength": {
      "type": "integer",
      "default": 28,
      "maximum": 45,
      "minimum": 20,
      "description": "Cycle length in days, 20 to 45 (default 28)"
    }
  }
}

{
  "type": "object",
  "required": [
    "count"
  ],
  "properties": {
    "count": {
      "type": "integer",
      "maximum": 1000,
      "minimum": 1,
      "description": "How many records to generate, from 1 to 1000"
    },
    "fields": {
      "type": "array",
      "items": {
        "enum": [
          "firstName",
          "lastName",
          "fullName",
          "email",
          "ukMobile",
          "ukLandline",
          "streetAddress",
          "town",
          "postcode",
          "dateOfBirth",
          "company"
        ],
        "type": "string"
      },
      "description": "Which fields to include (default all). Choose from firstName, lastName, fullName, email, ukMobile, ukLandline, streetAddress, town, postcode, dateOfBirth, company"
    }
  }
}

{
  "type": "object",
  "required": [
    "headers"
  ],
  "properties": {
    "headers": {
      "type": "string",
      "minLength": 1,
      "description": "The raw message headers, pasted as text"
    }
  }
}

{
  "type": "object",
  "required": [
    "to"
  ],
  "properties": {
    "cc": {
      "type": "string",
      "description": "Optional cc addresses, separated by commas or semicolons"
    },
    "to": {
      "type": "string",
      "minLength": 1,
      "description": "One or more recipient addresses, separated by commas or semicolons"
    },
    "bcc": {
      "type": "string",
      "description": "Optional bcc addresses, separated by commas or semicolons"
    },
    "body": {
      "type": "string",
      "description": "Optional body text; line breaks are preserved"
    },
    "subject": {
      "type": "string",
      "description": "Optional subject line"
    },
    "linkText": {
      "type": "string",
      "default": "Email us",
      "description": "Optional visible text for the HTML anchor (default 'Email us')"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to clean"
    }
  }
}

{
  "type": "object",
  "required": [
    "watts",
    "hoursPerDay",
    "pencePerKwh"
  ],
  "properties": {
    "watts": {
      "type": "number",
      "maximum": 100000,
      "minimum": 0,
      "description": "Appliance power draw in watts (0 to 100000)"
    },
    "hoursPerDay": {
      "type": "number",
      "maximum": 24,
      "minimum": 0,
      "description": "Hours used per day (0 to 24)"
    },
    "pencePerKwh": {
      "type": "number",
      "minimum": 0,
      "description": "Electricity unit price in pence per kWh"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "mode": {
      "enum": [
        "env-to-json",
        "json-to-env"
      ],
      "type": "string",
      "default": "env-to-json",
      "description": "'env-to-json' parses a .env file into JSON, 'json-to-env' turns a JSON object into .env lines (default env-to-json)"
    },
    "text": {
      "type": "string",
      "description": "The .env file text, or the JSON object text, depending on mode"
    }
  }
}

{
  "type": "object",
  "required": [
    "address"
  ],
  "properties": {
    "address": {
      "type": "string",
      "description": "The Ethereum address, with or without a 0x prefix"
    }
  }
}

{
  "type": "object",
  "required": [
    "amount",
    "unit"
  ],
  "properties": {
    "unit": {
      "enum": [
        "wei",
        "gwei",
        "eth"
      ],
      "type": "string",
      "description": "The unit the amount is given in"
    },
    "amount": {
      "type": "string",
      "description": "The amount to convert, as a plain number (string preferred to keep full precision), e.g. \"1.5\""
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "lines": {
      "type": "integer",
      "default": 1,
      "maximum": 10,
      "minimum": 1,
      "description": "How many lines to generate, 1 to 10 (default 1)"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {}
}

{
  "type": "object",
  "required": [
    "op",
    "n1",
    "d1",
    "n2",
    "d2"
  ],
  "properties": {
    "d1": {
      "not": {
        "const": 0
      },
      "type": "integer",
      "description": "First denominator (not zero)"
    },
    "d2": {
      "not": {
        "const": 0
      },
      "type": "integer",
      "description": "Second denominator (not zero)"
    },
    "n1": {
      "type": "integer",
      "description": "First numerator"
    },
    "n2": {
      "type": "integer",
      "description": "Second numerator"
    },
    "op": {
      "enum": [
        "add",
        "sub",
        "mul",
        "div"
      ],
      "type": "string",
      "description": "Operation: add, sub (subtract), mul (multiply) or div (divide)"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "toDecimal"
          }
        }
      },
      "then": {
        "required": [
          "numerator",
          "denominator"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "toFraction"
          }
        }
      },
      "then": {
        "required": [
          "decimal"
        ]
      }
    }
  ],
  "required": [
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "toDecimal",
        "toFraction"
      ],
      "type": "string",
      "description": "'toDecimal' from a fraction, or 'toFraction' from a decimal"
    },
    "decimal": {
      "type": "number",
      "description": "The decimal to convert (mode 'toFraction')"
    },
    "numerator": {
      "type": "integer",
      "description": "Numerator (mode 'toDecimal')"
    },
    "denominator": {
      "not": {
        "const": 0
      },
      "type": "integer",
      "description": "Denominator, not zero (mode 'toDecimal')"
    }
  }
}

{
  "type": "object",
  "required": [
    "miles",
    "mpg",
    "pencePerLitre"
  ],
  "properties": {
    "mpg": {
      "type": "number",
      "description": "Fuel economy in miles per UK gallon",
      "exclusiveMinimum": 0
    },
    "miles": {
      "type": "number",
      "minimum": 0,
      "description": "One-way distance in miles"
    },
    "people": {
      "type": "integer",
      "default": 1,
      "maximum": 1000,
      "minimum": 1,
      "description": "Number of people to split the cost between (default 1)"
    },
    "returnTrip": {
      "type": "boolean",
      "default": false,
      "description": "Double the distance for a return journey (default false)"
    },
    "pencePerLitre": {
      "type": "number",
      "minimum": 0,
      "description": "Pump price in pence per litre"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to hash"
    },
    "algorithm": {
      "enum": [
        "SHA-256",
        "SHA-1",
        "SHA-512"
      ],
      "type": "string",
      "default": "SHA-256",
      "description": "Hash algorithm (default SHA-256)"
    }
  }
}

{
  "type": "object",
  "required": [
    "hash"
  ],
  "properties": {
    "hash": {
      "type": "string",
      "minLength": 1,
      "description": "The hash string to identify"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "method": {
            "const": "karvonen"
          }
        }
      },
      "then": {
        "required": [
          "restingHeartRate"
        ]
      }
    }
  ],
  "required": [
    "age"
  ],
  "properties": {
    "age": {
      "type": "number",
      "maximum": 120,
      "description": "Age in years",
      "exclusiveMinimum": 0
    },
    "method": {
      "enum": [
        "max",
        "karvonen"
      ],
      "type": "string",
      "default": "max",
      "description": "'max' (percentage of max HR) or 'karvonen' (heart rate reserve). Default 'max'"
    },
    "restingHeartRate": {
      "type": "number",
      "description": "Resting heart rate in bpm, required for the Karvonen method",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "hex"
  ],
  "properties": {
    "hex": {
      "type": "string",
      "pattern": "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
      "description": "Hex colour code, e.g. #D7263D or F0C"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "description": "The text to scan"
    },
    "plainPunctuation": {
      "type": "boolean",
      "description": "Also flatten curly quotes, en and em dashes and ellipses to plain ASCII in the cleaned text"
    }
  }
}

{
  "type": "object",
  "required": [
    "daysPerWeek"
  ],
  "properties": {
    "months": {
      "type": "number",
      "default": 12,
      "maximum": 12,
      "description": "Months of the year worked (1 to 12, default 12)",
      "exclusiveMinimum": 0
    },
    "daysPerWeek": {
      "type": "number",
      "maximum": 7,
      "description": "Days worked per week (1 to 7)",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "to_salary"
          }
        }
      },
      "then": {
        "required": [
          "hourlyRate"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "to_hourly"
          }
        }
      },
      "then": {
        "required": [
          "salary"
        ]
      }
    }
  ],
  "required": [
    "mode",
    "hoursPerWeek"
  ],
  "properties": {
    "mode": {
      "enum": [
        "to_salary",
        "to_hourly"
      ],
      "type": "string",
      "description": "'to_salary' from an hourly rate, or 'to_hourly' from a salary"
    },
    "salary": {
      "type": "number",
      "maximum": 10000000,
      "minimum": 0,
      "description": "Annual salary in GBP (required for to_hourly)"
    },
    "hourlyRate": {
      "type": "number",
      "maximum": 100000,
      "minimum": 0,
      "description": "Hourly pay rate in GBP (required for to_salary)"
    },
    "hoursPerWeek": {
      "type": "number",
      "maximum": 168,
      "description": "Hours worked per week (greater than 0, up to 168)",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "start",
    "end"
  ],
  "properties": {
    "end": {
      "type": "string",
      "format": "time",
      "description": "End time in 24-hour HH:MM format, e.g. 17:30"
    },
    "start": {
      "type": "string",
      "format": "time",
      "description": "Start time in 24-hour HH:MM format, e.g. 09:00"
    },
    "breakMinutes": {
      "type": "number",
      "default": 0,
      "minimum": 0,
      "description": "Unpaid break in minutes (default 0)"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "hex_to_hsl"
          }
        }
      },
      "then": {
        "required": [
          "hex"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "hsl_to_hex"
          }
        }
      },
      "then": {
        "required": [
          "h",
          "s",
          "l"
        ]
      }
    }
  ],
  "required": [
    "mode"
  ],
  "properties": {
    "h": {
      "type": "number",
      "maximum": 360,
      "minimum": 0,
      "description": "Hue 0 to 360 (for hsl_to_hex)"
    },
    "l": {
      "type": "number",
      "maximum": 100,
      "minimum": 0,
      "description": "Lightness 0 to 100 (for hsl_to_hex)"
    },
    "s": {
      "type": "number",
      "maximum": 100,
      "minimum": 0,
      "description": "Saturation 0 to 100 (for hsl_to_hex)"
    },
    "hex": {
      "type": "string",
      "pattern": "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
      "description": "Hex colour code, e.g. #1FE85C (for hex_to_hsl)"
    },
    "mode": {
      "enum": [
        "hex_to_hsl",
        "hsl_to_hex"
      ],
      "type": "string",
      "description": "Direction of conversion"
    }
  }
}

{
  "type": "object",
  "required": [
    "text",
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "escape",
        "unescape"
      ],
      "type": "string",
      "description": "'escape' text to entities, or 'unescape' entities back to text"
    },
    "text": {
      "type": "string",
      "description": "The text to escape, or the HTML with entities to unescape"
    }
  }
}

{
  "type": "object",
  "anyOf": [
    {
      "required": [
        "code"
      ]
    },
    {
      "required": [
        "query"
      ]
    }
  ],
  "required": [],
  "properties": {
    "code": {
      "type": "integer",
      "maximum": 599,
      "minimum": 100,
      "description": "An HTTP status code to look up, for example 404"
    },
    "query": {
      "type": "string",
      "description": "A word to search for across code numbers, names and descriptions"
    }
  }
}

{
  "type": "object",
  "properties": {
    "iban": {
      "type": "string",
      "description": "An IBAN to validate (spaces and case are ignored)"
    },
    "country": {
      "type": "string",
      "description": "A two-letter country code (e.g. GB, DE, FR) to generate a test IBAN for instead of validating"
    }
  }
}

{
  "type": "object",
  "required": [
    "json"
  ],
  "properties": {
    "json": {
      "type": "string",
      "minLength": 1,
      "description": "The JSON text to process"
    },
    "mode": {
      "enum": [
        "format",
        "minify",
        "validate"
      ],
      "type": "string",
      "default": "format",
      "description": "'format' to pretty print, 'minify' to strip whitespace, 'validate' to only check validity (default format)"
    },
    "indent": {
      "type": "integer",
      "default": 2,
      "minimum": 0,
      "description": "Number of spaces per indent level when formatting (default 2)"
    }
  }
}

{
  "type": "object",
  "required": [
    "json"
  ],
  "properties": {
    "json": {
      "type": "string",
      "minLength": 1,
      "description": "A JSON array of objects to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "json"
  ],
  "properties": {
    "json": {
      "type": "string",
      "description": "A JSON sample to convert. It may be an object, an array or a primitive value."
    },
    "rootName": {
      "type": "string",
      "default": "Root",
      "description": "Name for the root interface or type alias (default Root)."
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "mode": {
      "enum": [
        "json-to-yaml",
        "yaml-to-json"
      ],
      "type": "string",
      "default": "json-to-yaml",
      "description": "Direction of conversion (default json-to-yaml)"
    },
    "text": {
      "type": "string",
      "description": "The JSON or YAML text to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "token"
  ],
  "properties": {
    "token": {
      "type": "string",
      "minLength": 1,
      "description": "The JWT to decode, optionally with a leading 'Bearer ' prefix"
    }
  }
}

{
  "type": "object",
  "required": [
    "kilograms"
  ],
  "properties": {
    "kilograms": {
      "type": "number",
      "minimum": 0,
      "description": "Weight in kilograms"
    }
  }
}

{
  "type": "object",
  "required": [
    "kilograms"
  ],
  "properties": {
    "kilograms": {
      "type": "number",
      "minimum": 0,
      "description": "Weight in kilograms"
    }
  }
}

{
  "type": "object",
  "required": [
    "pounds"
  ],
  "properties": {
    "pounds": {
      "type": "number",
      "minimum": 0,
      "description": "Weight in pounds (decimals allowed, e.g. 7.5 for 7 lb 8 oz)"
    }
  }
}

{
  "type": "object",
  "required": [
    "mode",
    "text"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "Trace: the tracer key returned by mark, instead of recipients"
    },
    "mode": {
      "enum": [
        "mark",
        "trace"
      ],
      "type": "string",
      "description": "mark or trace"
    },
    "text": {
      "type": "string",
      "minLength": 1,
      "description": "Mark: the document. Trace: the leaked copy or fragment"
    },
    "spacing": {
      "type": "boolean",
      "description": "Mark: also encode the pattern as no-break spaces"
    },
    "recipients": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 255,
      "description": "Recipient names in order (mark: required; trace: this or key)"
    }
  }
}

{
  "type": "object",
  "required": [
    "year"
  ],
  "properties": {
    "year": {
      "type": "integer",
      "maximum": 9999,
      "minimum": 1,
      "description": "The year to check (1 to 9999)"
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "enum": [
        "mm",
        "cm",
        "m",
        "km",
        "in",
        "ft",
        "yd",
        "mi"
      ],
      "type": "string",
      "description": "Unit to convert to"
    },
    "from": {
      "enum": [
        "mm",
        "cm",
        "m",
        "km",
        "in",
        "ft",
        "yd",
        "mi"
      ],
      "type": "string",
      "description": "Unit to convert from"
    },
    "value": {
      "type": "number",
      "minimum": 0,
      "description": "The length value to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "description": "The link to clean and inspect"
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "direction"
  ],
  "properties": {
    "value": {
      "type": "number",
      "minimum": 0,
      "description": "The value to convert (litres or UK pints depending on direction)"
    },
    "direction": {
      "enum": [
        "litres-to-pints",
        "pints-to-litres"
      ],
      "type": "string",
      "description": "Which way to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "amount",
    "rate",
    "years"
  ],
  "properties": {
    "rate": {
      "type": "number",
      "maximum": 100,
      "minimum": 0,
      "description": "Annual interest rate (APR) as a percentage (0 to 100)"
    },
    "years": {
      "type": "number",
      "maximum": 30,
      "description": "Loan term in years (greater than 0, up to 30)",
      "exclusiveMinimum": 0
    },
    "amount": {
      "type": "number",
      "description": "Amount borrowed in GBP (greater than zero)",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "domain"
  ],
  "properties": {
    "domain": {
      "type": "string",
      "minLength": 1,
      "description": "The domain to check, e.g. example.co.uk"
    },
    "techniques": {
      "type": "array",
      "items": {
        "enum": [
          "omission",
          "repetition",
          "transposition",
          "keyboard",
          "vowel",
          "homoglyph",
          "confusable",
          "hyphenation",
          "subdomain",
          "tld"
        ],
        "type": "string"
      },
      "description": "Optional subset of techniques to use; omit for all"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "paragraphs"
          }
        }
      },
      "then": {
        "properties": {
          "count": {
            "maximum": 100
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "sentences"
          }
        }
      },
      "then": {
        "properties": {
          "count": {
            "maximum": 500
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "words"
          }
        }
      },
      "then": {
        "properties": {
          "count": {
            "maximum": 2000
          }
        }
      }
    }
  ],
  "required": [
    "count"
  ],
  "properties": {
    "mode": {
      "enum": [
        "paragraphs",
        "sentences",
        "words"
      ],
      "type": "string",
      "default": "paragraphs",
      "description": "What the count refers to (default paragraphs)"
    },
    "count": {
      "type": "integer",
      "minimum": 1,
      "description": "How many paragraphs, sentences or words to produce"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "game": {
      "enum": [
        "lotto",
        "thunderball",
        "setforlife"
      ],
      "type": "string",
      "default": "lotto",
      "description": "Which game to play (default lotto)"
    },
    "lines": {
      "type": "integer",
      "default": 1,
      "maximum": 10,
      "minimum": 1,
      "description": "How many lines to generate, 1 to 10 (default 1)"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "question": {
      "type": "string",
      "description": "The yes or no question to ask (optional)"
    }
  }
}

{
  "type": "object",
  "required": [
    "cost",
    "price"
  ],
  "properties": {
    "cost": {
      "type": "number",
      "maximum": 1000000000,
      "minimum": 0,
      "description": "Cost price in GBP"
    },
    "price": {
      "type": "number",
      "maximum": 1000000000,
      "minimum": 0,
      "description": "Selling price in GBP"
    }
  }
}

{
  "type": "object",
  "required": [
    "markdown"
  ],
  "properties": {
    "markdown": {
      "type": "string",
      "description": "The markdown source to render"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "market_cap"
          }
        }
      },
      "then": {
        "required": [
          "price"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "implied_price"
          }
        }
      },
      "then": {
        "required": [
          "target"
        ]
      }
    }
  ],
  "required": [
    "mode",
    "supply"
  ],
  "properties": {
    "mode": {
      "enum": [
        "market_cap",
        "implied_price"
      ],
      "type": "string",
      "description": "market_cap: price times supply. implied_price: target cap divided by supply."
    },
    "price": {
      "type": "number",
      "minimum": 0,
      "description": "Current price per coin (for market_cap)"
    },
    "supply": {
      "type": "number",
      "description": "Circulating supply (for both modes)",
      "exclusiveMinimum": 0
    },
    "target": {
      "type": "number",
      "minimum": 0,
      "description": "Target market cap (for implied_price)"
    },
    "current": {
      "type": "number",
      "minimum": 0,
      "description": "Current price per coin, to show the multiple (optional, implied_price mode)"
    },
    "maxSupply": {
      "type": "number",
      "minimum": 0,
      "description": "Maximum or total supply for FDV (optional, market_cap mode)"
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "direction"
  ],
  "properties": {
    "value": {
      "type": "number",
      "minimum": 0,
      "description": "The distance value to convert"
    },
    "direction": {
      "enum": [
        "miles-to-km",
        "km-to-miles"
      ],
      "type": "string",
      "description": "Which way to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "time",
    "direction"
  ],
  "properties": {
    "time": {
      "type": "string",
      "minLength": 1,
      "description": "The time to convert, e.g. '1430', '14:30', '2:30 pm'"
    },
    "meridiem": {
      "enum": [
        "am",
        "pm"
      ],
      "type": "string",
      "default": "pm",
      "description": "am or pm for 12h-to-24h when not in the time string (default pm)"
    },
    "direction": {
      "enum": [
        "24h-to-12h",
        "12h-to-24h"
      ],
      "type": "string",
      "description": "Which way to convert"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "minutesToHours"
          }
        }
      },
      "then": {
        "required": [
          "minutes"
        ]
      }
    }
  ],
  "required": [
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "minutesToHours",
        "hoursToMinutes"
      ],
      "type": "string",
      "description": "Direction of the conversion"
    },
    "hours": {
      "type": "number",
      "default": 0,
      "maximum": 100000,
      "minimum": 0,
      "description": "Hours to convert (used when mode is 'hoursToMinutes', 0 to 100000)"
    },
    "minutes": {
      "type": "number",
      "maximum": 10000000,
      "minimum": 0,
      "description": "Minutes to convert (used when mode is 'minutesToHours', 0 to 10000000)"
    },
    "extraMinutes": {
      "type": "number",
      "default": 0,
      "maximum": 10000000,
      "minimum": 0,
      "description": "Extra minutes to add to the hours (used when mode is 'hoursToMinutes', default 0)"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "date": {
      "type": "string",
      "format": "date",
      "description": "Optional date in YYYY-MM-DD format (defaults to today)"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text or Morse code to translate"
    },
    "direction": {
      "enum": [
        "t2m",
        "m2t"
      ],
      "type": "string",
      "default": "t2m",
      "description": "'t2m' text to Morse (default), 'm2t' Morse to text"
    }
  }
}

{
  "type": "object",
  "required": [
    "amount",
    "rate",
    "years"
  ],
  "properties": {
    "rate": {
      "type": "number",
      "maximum": 50,
      "minimum": 0,
      "description": "Annual interest rate as a percentage (0 to 50)"
    },
    "years": {
      "type": "number",
      "maximum": 50,
      "description": "Mortgage term in years (greater than 0, up to 50)",
      "exclusiveMinimum": 0
    },
    "amount": {
      "type": "number",
      "description": "Amount borrowed in GBP (greater than zero)",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "balance",
    "rate",
    "years",
    "extra"
  ],
  "properties": {
    "rate": {
      "type": "number",
      "maximum": 50,
      "minimum": 0,
      "description": "Annual interest rate as a percentage (0 to 50)"
    },
    "extra": {
      "type": "number",
      "minimum": 0,
      "description": "Extra monthly overpayment in GBP (0 or more)"
    },
    "years": {
      "type": "number",
      "maximum": 50,
      "description": "Remaining term in years (greater than 0, up to 50)",
      "exclusiveMinimum": 0
    },
    "balance": {
      "type": "number",
      "description": "Current mortgage balance in GBP (greater than zero)",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "direction"
  ],
  "properties": {
    "value": {
      "type": "number",
      "description": "The fuel economy value (UK mpg or L/100km depending on direction)",
      "exclusiveMinimum": 0
    },
    "direction": {
      "enum": [
        "mpg-to-l100",
        "l100-to-mpg"
      ],
      "type": "string",
      "description": "Which way to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "salary"
  ],
  "properties": {
    "salary": {
      "type": "number",
      "maximum": 10000000,
      "minimum": 0,
      "description": "Annual gross salary in GBP"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text or phonetic spelling to convert"
    },
    "direction": {
      "enum": [
        "t2n",
        "n2t"
      ],
      "type": "string",
      "default": "t2n",
      "description": "'t2n' text to phonetic (default), 'n2t' phonetic to text"
    }
  }
}

{
  "type": "object",
  "required": [
    "net"
  ],
  "properties": {
    "net": {
      "type": "number",
      "minimum": 0,
      "description": "Desired take-home pay in GBP"
    },
    "period": {
      "enum": [
        "year",
        "month"
      ],
      "type": "string",
      "default": "year",
      "description": "Whether the net figure is yearly or monthly (default year)"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "from": {
      "type": "string",
      "description": "Optional moment to count from: YYYY-MM-DD (taken as 00:00 UTC) or a full ISO 8601 date-time such as 2026-12-31T18:30:00Z. Defaults to now."
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "fromBase",
    "toBase"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "The number to convert, as text (optional 0b/0o/0x prefix, spaces and underscores ignored, may be negative)"
    },
    "toBase": {
      "enum": [
        "binary",
        "octal",
        "decimal",
        "hex"
      ],
      "type": "string",
      "description": "The base to convert to"
    },
    "fromBase": {
      "enum": [
        "binary",
        "octal",
        "decimal",
        "hex"
      ],
      "type": "string",
      "description": "The base the value is written in"
    }
  }
}

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "minLength": 1,
      "description": "The number to spell out, e.g. '1234.5' or '19.99'. May include commas."
    },
    "currency": {
      "type": "boolean",
      "default": false,
      "description": "Write as UK pounds and pence (default false)"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "scale": {
            "const": "gas"
          }
        }
      },
      "then": {
        "properties": {
          "value": {
            "type": "integer",
            "maximum": 9,
            "minimum": 1
          }
        }
      }
    }
  ],
  "required": [
    "value",
    "scale"
  ],
  "properties": {
    "scale": {
      "enum": [
        "c",
        "fan",
        "f",
        "gas"
      ],
      "type": "string",
      "description": "The scale of the input value"
    },
    "value": {
      "type": "number",
      "description": "The temperature value (or gas mark 1 to 9 when scale is 'gas')"
    }
  }
}

{
  "type": "object",
  "required": [
    "rate"
  ],
  "properties": {
    "rate": {
      "type": "number",
      "maximum": 100000,
      "minimum": 0,
      "description": "Base hourly rate in GBP"
    },
    "doubleHours": {
      "type": "number",
      "default": 0,
      "maximum": 10000,
      "minimum": 0,
      "description": "Hours paid at double time, 2x (default 0)"
    },
    "standardHours": {
      "type": "number",
      "default": 0,
      "maximum": 10000,
      "minimum": 0,
      "description": "Hours paid at the standard rate (default 0)"
    },
    "timeAndHalfHours": {
      "type": "number",
      "default": 0,
      "maximum": 10000,
      "minimum": 0,
      "description": "Hours paid at time and a half, 1.5x (default 0)"
    }
  }
}

{
  "type": "object",
  "required": [
    "password"
  ],
  "properties": {
    "password": {
      "type": "string",
      "minLength": 1,
      "description": "The password to assess (never uploaded; assessed locally)"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "of"
          }
        }
      },
      "then": {
        "required": [
          "percent",
          "number"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "what"
          }
        }
      },
      "then": {
        "required": [
          "part",
          "whole"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "change"
          }
        }
      },
      "then": {
        "required": [
          "from",
          "to"
        ]
      }
    }
  ],
  "required": [
    "mode"
  ],
  "properties": {
    "to": {
      "type": "number",
      "description": "End value (mode 'change')"
    },
    "from": {
      "not": {
        "const": 0
      },
      "type": "number",
      "description": "Starting value (mode 'change', not zero)"
    },
    "mode": {
      "enum": [
        "of",
        "what",
        "change"
      ],
      "type": "string",
      "description": "'of' percent of a number, 'what' one number as a percentage of another, or 'change' percentage change"
    },
    "part": {
      "type": "number",
      "description": "The part (mode 'what')"
    },
    "whole": {
      "not": {
        "const": 0
      },
      "type": "number",
      "description": "The whole (mode 'what', not zero)"
    },
    "number": {
      "type": "number",
      "description": "The number (mode 'of')"
    },
    "percent": {
      "type": "number",
      "description": "The percentage (mode 'of')"
    }
  }
}

{
  "type": "object",
  "required": [
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "type": "number",
      "description": "The end value"
    },
    "from": {
      "not": {
        "const": 0
      },
      "type": "number",
      "description": "The starting value (not zero)"
    }
  }
}

{
  "type": "object",
  "required": [
    "number",
    "percent"
  ],
  "properties": {
    "number": {
      "type": "number",
      "description": "The starting number"
    },
    "percent": {
      "type": "number",
      "description": "The percentage to take off"
    }
  }
}

{
  "type": "object",
  "required": [
    "a",
    "b"
  ],
  "properties": {
    "a": {
      "type": "number",
      "description": "The first value"
    },
    "b": {
      "type": "number",
      "description": "The second value"
    }
  }
}

{
  "type": "object",
  "required": [
    "number",
    "percent"
  ],
  "properties": {
    "number": {
      "type": "number",
      "description": "The starting number"
    },
    "percent": {
      "type": "number",
      "description": "The percentage to add on"
    }
  }
}

{
  "type": "object",
  "required": [
    "account",
    "risk",
    "entry",
    "stop"
  ],
  "properties": {
    "risk": {
      "type": "number",
      "maximum": 100,
      "description": "Percentage of the account to risk on this trade (above 0, up to 100)",
      "exclusiveMinimum": 0
    },
    "stop": {
      "type": "number",
      "minimum": 0,
      "description": "Stop-loss price per unit"
    },
    "entry": {
      "type": "number",
      "description": "Entry price per unit",
      "exclusiveMinimum": 0
    },
    "account": {
      "type": "number",
      "description": "Total account size",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "enum": [
        "w",
        "kw",
        "hp",
        "ps"
      ],
      "type": "string",
      "description": "Unit to convert to"
    },
    "from": {
      "enum": [
        "w",
        "kw",
        "hp",
        "ps"
      ],
      "type": "string",
      "description": "Unit to convert from"
    },
    "value": {
      "type": "number",
      "minimum": 0,
      "description": "The power value to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "enum": [
        "bar",
        "psi",
        "kpa",
        "atm"
      ],
      "type": "string",
      "description": "Unit to convert to"
    },
    "from": {
      "enum": [
        "bar",
        "psi",
        "kpa",
        "atm"
      ],
      "type": "string",
      "description": "Unit to convert from"
    },
    "value": {
      "type": "number",
      "minimum": 0,
      "description": "The pressure value to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "number"
  ],
  "properties": {
    "number": {
      "type": "integer",
      "maximum": 1000000000000000,
      "minimum": 2,
      "description": "A whole number from 2 to 1,000,000,000,000,000"
    }
  }
}

{
  "type": "object",
  "required": [
    "fullTimeSalary",
    "fullTimeHours",
    "hours"
  ],
  "properties": {
    "hours": {
      "type": "number",
      "description": "Your hours per week (greater than zero)",
      "exclusiveMinimum": 0
    },
    "fullTimeHours": {
      "type": "number",
      "description": "Full-time hours per week (greater than zero)",
      "exclusiveMinimum": 0
    },
    "fullTimeSalary": {
      "type": "number",
      "description": "Full-time annual salary in GBP (greater than zero)",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {}
}

{
  "type": "object",
  "required": [],
  "properties": {
    "decimals": {
      "type": "integer",
      "default": 4,
      "maximum": 6,
      "minimum": 2,
      "description": "Decimal places for each coordinate, 2 to 6 (default 4)"
    },
    "quantity": {
      "type": "integer",
      "default": 1,
      "maximum": 100,
      "minimum": 1,
      "description": "How many points to generate, 1 to 100 (default 1)"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "set": {
      "enum": [
        "any",
        "vowels",
        "consonants"
      ],
      "type": "string",
      "default": "any",
      "description": "Which letters to draw from (default any)"
    },
    "quantity": {
      "type": "integer",
      "default": 1,
      "maximum": 100,
      "minimum": 1,
      "description": "How many letters to generate, 1 to 100 (default 1)"
    }
  }
}

{
  "type": "object",
  "required": [
    "min",
    "max"
  ],
  "properties": {
    "max": {
      "type": "integer",
      "description": "Highest possible number (inclusive)"
    },
    "min": {
      "type": "integer",
      "description": "Lowest possible number (inclusive)"
    },
    "unique": {
      "type": "boolean",
      "default": false,
      "description": "If true, no number repeats (default false)"
    },
    "quantity": {
      "type": "integer",
      "default": 1,
      "maximum": 1000,
      "minimum": 1,
      "description": "How many numbers to generate, 1 to 1000 (default 1)"
    }
  }
}

{
  "type": "object",
  "required": [
    "names",
    "teams"
  ],
  "properties": {
    "names": {
      "type": "array",
      "minItems": 1,
      "description": "The list of names to split into teams"
    },
    "teams": {
      "type": "integer",
      "maximum": 20,
      "minimum": 2,
      "description": "How many teams to make, 2 to 20"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "quantity": {
      "type": "integer",
      "default": 1,
      "maximum": 20,
      "minimum": 1,
      "description": "How many words to generate, 1 to 20 (default 1)"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "solve"
          }
        }
      },
      "then": {
        "required": [
          "c"
        ]
      }
    }
  ],
  "required": [
    "mode",
    "a",
    "b"
  ],
  "properties": {
    "a": {
      "type": "number",
      "description": "First term of the ratio (positive)",
      "exclusiveMinimum": 0
    },
    "b": {
      "type": "number",
      "description": "Second term of the ratio (positive)",
      "exclusiveMinimum": 0
    },
    "c": {
      "type": "number",
      "description": "Known term of the equivalent ratio, mode 'solve' (a : b = c : x)",
      "exclusiveMinimum": 0
    },
    "mode": {
      "enum": [
        "simplify",
        "solve"
      ],
      "type": "string",
      "description": "'simplify' a ratio, or 'solve' for the missing value"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to measure"
    }
  }
}

{
  "type": "object",
  "required": [
    "age",
    "years",
    "weeklyPay"
  ],
  "properties": {
    "age": {
      "type": "integer",
      "maximum": 100,
      "minimum": 15,
      "description": "Age at redundancy (15 to 100)"
    },
    "years": {
      "type": "integer",
      "maximum": 60,
      "minimum": 0,
      "description": "Full years of continuous service (0 to 60, cannot exceed age)"
    },
    "weeklyPay": {
      "type": "number",
      "maximum": 1000000,
      "description": "Gross weekly pay in GBP",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to deduplicate, one item per line"
    },
    "caseInsensitive": {
      "type": "boolean",
      "default": false,
      "description": "Treat lines that differ only in case as duplicates (default false)"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to clean"
    },
    "removeBlankLines": {
      "type": "boolean",
      "default": false,
      "description": "Also drop empty lines (default false)"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "mode": {
      "enum": [
        "spaces",
        "paragraphs"
      ],
      "type": "string",
      "default": "spaces",
      "description": "'spaces' joins everything into one block (default), 'paragraphs' keeps paragraph breaks"
    },
    "text": {
      "type": "string",
      "description": "The text to join"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "mode": {
      "enum": [
        "characters",
        "words",
        "each"
      ],
      "type": "string",
      "default": "characters",
      "description": "'characters' (default), 'words' reverses word order per line, 'each' reverses letters within each word"
    },
    "text": {
      "type": "string",
      "description": "The text to reverse"
    }
  }
}

{
  "type": "object",
  "required": [
    "r",
    "g",
    "b"
  ],
  "properties": {
    "b": {
      "type": "integer",
      "maximum": 255,
      "minimum": 0,
      "description": "Blue, 0 to 255"
    },
    "g": {
      "type": "integer",
      "maximum": 255,
      "minimum": 0,
      "description": "Green, 0 to 255"
    },
    "r": {
      "type": "integer",
      "maximum": 255,
      "minimum": 0,
      "description": "Red, 0 to 255"
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "uk",
        "us",
        "mm"
      ],
      "type": "string",
      "description": "Which scale the value is in"
    },
    "value": {
      "type": "string",
      "minLength": 1,
      "description": "The ring size to convert: a UK letter (uk mode), or a number (us or mm mode)"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "preset": {
            "const": "custom"
          }
        }
      },
      "then": {
        "required": [
          "rules"
        ]
      }
    }
  ],
  "required": [],
  "properties": {
    "rules": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "path": {
            "type": "string",
            "description": "Path such as /private/ (blank disallow means allow everything)"
          },
          "agent": {
            "type": "string",
            "default": "*",
            "description": "User agent, default '*' for all crawlers"
          },
          "directive": {
            "enum": [
              "allow",
              "disallow"
            ],
            "type": "string",
            "default": "disallow",
            "description": "'allow' or 'disallow' (default disallow)"
          }
        }
      },
      "description": "Custom rules, each an object with agent, directive and path"
    },
    "preset": {
      "enum": [
        "allow",
        "block",
        "wordpress",
        "custom"
      ],
      "type": "string",
      "description": "Use a ready-made rule set instead of custom rules"
    },
    "sitemap": {
      "type": "string",
      "format": "uri",
      "description": "Optional sitemap URL for the Sitemap line"
    }
  }
}

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "pattern": "^\\s*(\\d+|[IVXLCDMivxlcdm]+)\\s*$",
      "minLength": 1,
      "description": "A whole number from 1 to 3999, or a Roman numeral using I, V, X, L, C, D and M"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "dp"
          }
        }
      },
      "then": {
        "properties": {
          "count": {
            "maximum": 12,
            "minimum": 0
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "sf"
          }
        }
      },
      "then": {
        "properties": {
          "count": {
            "maximum": 15,
            "minimum": 1
          }
        }
      }
    }
  ],
  "required": [
    "number",
    "mode",
    "count"
  ],
  "properties": {
    "mode": {
      "enum": [
        "dp",
        "sf"
      ],
      "type": "string",
      "description": "'dp' for decimal places, or 'sf' for significant figures"
    },
    "count": {
      "type": "integer",
      "maximum": 15,
      "minimum": 0,
      "description": "How many decimal places (0 to 12) or significant figures (1 to 15)"
    },
    "number": {
      "type": "number",
      "description": "The number to round"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "pace"
          }
        }
      },
      "then": {
        "required": [
          "distance",
          "timeSeconds"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "time"
          }
        }
      },
      "then": {
        "required": [
          "distance",
          "paceSeconds"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "distance"
          }
        }
      },
      "then": {
        "required": [
          "timeSeconds",
          "paceSeconds"
        ]
      }
    }
  ],
  "required": [
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "pace",
        "time",
        "distance"
      ],
      "type": "string",
      "description": "Which value to solve for"
    },
    "unit": {
      "enum": [
        "km",
        "mi"
      ],
      "type": "string",
      "default": "km",
      "description": "Unit for distance and the given pace. Default 'km'"
    },
    "distance": {
      "type": "number",
      "description": "Distance in the chosen unit (needed for 'pace' and 'time' modes)",
      "exclusiveMinimum": 0
    },
    "paceSeconds": {
      "type": "number",
      "description": "Pace in seconds per unit (needed for 'time' and 'distance' modes)",
      "exclusiveMinimum": 0
    },
    "timeSeconds": {
      "type": "number",
      "description": "Total time in seconds (needed for 'pace' and 'distance' modes)",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "mode",
    "value"
  ],
  "properties": {
    "mode": {
      "enum": [
        "sats_to_btc",
        "btc_to_sats"
      ],
      "type": "string",
      "description": "Direction of conversion"
    },
    "value": {
      "type": "string",
      "description": "The amount to convert: whole satoshis for sats_to_btc, or a BTC amount for btc_to_sats"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "monthly"
          }
        }
      },
      "then": {
        "required": [
          "years"
        ]
      }
    },
    {
      "if": {
        "properties": {
          "mode": {
            "const": "time"
          }
        }
      },
      "then": {
        "required": [
          "monthly"
        ]
      }
    }
  ],
  "required": [
    "mode",
    "target",
    "rate"
  ],
  "properties": {
    "mode": {
      "enum": [
        "time",
        "monthly"
      ],
      "type": "string",
      "description": "'time' finds the time to reach the goal; 'monthly' finds the monthly saving needed"
    },
    "rate": {
      "type": "number",
      "minimum": 0,
      "description": "Annual interest rate as a percentage"
    },
    "start": {
      "type": "number",
      "default": 0,
      "minimum": 0,
      "description": "Starting balance in GBP (default 0)"
    },
    "years": {
      "type": "number",
      "description": "Monthly mode: number of years to reach the goal",
      "exclusiveMinimum": 0
    },
    "target": {
      "type": "number",
      "description": "Savings target in GBP (greater than zero)",
      "exclusiveMinimum": 0
    },
    "monthly": {
      "type": "number",
      "minimum": 0,
      "description": "Time mode: monthly deposit in GBP"
    }
  }
}

{
  "type": "object",
  "required": [
    "expression"
  ],
  "properties": {
    "angleMode": {
      "enum": [
        "deg",
        "rad"
      ],
      "type": "string",
      "default": "deg",
      "description": "Angle units for trigonometry: 'deg' (default) or 'rad'"
    },
    "expression": {
      "type": "string",
      "minLength": 1,
      "description": "The maths expression, e.g. '2 + 3 * 4', 'sin(30)', 'sqrt(2)^2', '5!'"
    }
  }
}

{
  "type": "object",
  "required": [
    "names"
  ],
  "properties": {
    "names": {
      "type": "array",
      "minItems": 2,
      "description": "The list of participant names (at least two, no duplicates)"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "lines": {
      "type": "integer",
      "default": 1,
      "maximum": 10,
      "minimum": 1,
      "description": "How many lines to generate, 1 to 10 (default 1)"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "sex": {
            "const": "men"
          }
        }
      },
      "then": {
        "properties": {
          "ukSize": {
            "maximum": 13,
            "minimum": 5
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "sex": {
            "const": "women"
          }
        }
      },
      "then": {
        "properties": {
          "ukSize": {
            "maximum": 9,
            "minimum": 2
          }
        }
      }
    }
  ],
  "required": [
    "ukSize",
    "sex"
  ],
  "properties": {
    "sex": {
      "enum": [
        "men",
        "women"
      ],
      "type": "string",
      "description": "Which sizing chart to use"
    },
    "ukSize": {
      "type": "number",
      "maximum": 13,
      "minimum": 2,
      "multipleOf": 0.5,
      "description": "UK shoe size (whole or half, e.g. 8 or 8.5)"
    }
  }
}

{
  "type": "object",
  "required": [
    "mode",
    "time"
  ],
  "properties": {
    "mode": {
      "enum": [
        "wake",
        "bedtime"
      ],
      "type": "string",
      "description": "'wake' to find bedtimes from a wake time, or 'bedtime' to find wake times from a bedtime"
    },
    "time": {
      "type": "string",
      "format": "time",
      "description": "The known time as 'HH:MM' (24-hour): the wake time for mode 'wake', or the bedtime for mode 'bedtime'"
    }
  }
}

{
  "type": "object",
  "required": [
    "items"
  ],
  "properties": {
    "items": {
      "type": "array",
      "maxItems": 100,
      "minItems": 2,
      "description": "The list of names or options on the reel (at least two)"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "description": "The title or text to slugify"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to convert"
    },
    "style": {
      "enum": [
        "superscript",
        "smallcaps",
        "fullwidth"
      ],
      "type": "string",
      "default": "superscript",
      "description": "Which style to apply (default superscript)"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "group": {
      "enum": [
        "arrows",
        "stars",
        "maths",
        "currency",
        "punctuation",
        "legal",
        "accents"
      ],
      "type": "string",
      "description": "Optional: return only this group. Omit to return every group."
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "enum": [
        "mph",
        "kmh",
        "ms",
        "kn",
        "mach"
      ],
      "type": "string",
      "description": "Unit to convert to"
    },
    "from": {
      "enum": [
        "mph",
        "kmh",
        "ms",
        "kn",
        "mach"
      ],
      "type": "string",
      "description": "Unit to convert from"
    },
    "value": {
      "type": "number",
      "minimum": 0,
      "description": "The speed value to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "players"
  ],
  "properties": {
    "players": {
      "type": "array",
      "maxItems": 20,
      "minItems": 2,
      "description": "The list of players in the circle (at least two)"
    }
  }
}

{
  "type": "object",
  "required": [
    "sql"
  ],
  "properties": {
    "sql": {
      "type": "string",
      "minLength": 1,
      "description": "The SQL query to format"
    }
  }
}

{
  "type": "object",
  "required": [
    "principal",
    "rate",
    "years"
  ],
  "properties": {
    "rate": {
      "type": "number",
      "maximum": 1000,
      "minimum": 0,
      "description": "Quoted rate as a percentage (0 to 1000)"
    },
    "years": {
      "type": "number",
      "maximum": 100,
      "description": "Term in years (above 0, up to 100)",
      "exclusiveMinimum": 0
    },
    "rateType": {
      "enum": [
        "apr",
        "apy"
      ],
      "type": "string",
      "default": "apr",
      "description": "Whether the rate is APR (needs compounding) or APY (default apr)"
    },
    "principal": {
      "type": "number",
      "description": "Amount staked",
      "exclusiveMinimum": 0
    },
    "compounding": {
      "enum": [
        "daily",
        "monthly"
      ],
      "type": "string",
      "default": "daily",
      "description": "Compounding frequency for APR (default daily)"
    }
  }
}

{
  "type": "object",
  "required": [
    "price",
    "buyer"
  ],
  "properties": {
    "buyer": {
      "enum": [
        "ftb",
        "home",
        "additional"
      ],
      "type": "string",
      "description": "'ftb' first-time buyer, 'home' moving home, 'additional' second home or buy-to-let"
    },
    "price": {
      "type": "number",
      "maximum": 100000000,
      "description": "Property purchase price in GBP",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [
    "numbers"
  ],
  "properties": {
    "numbers": {
      "type": "string",
      "minLength": 1,
      "description": "A list of numbers separated by spaces, commas, semicolons or new lines"
    }
  }
}

{
  "type": "object",
  "required": [
    "date"
  ],
  "properties": {
    "date": {
      "type": "string",
      "format": "date",
      "description": "Date of birth in YYYY-MM-DD format"
    }
  }
}

{
  "type": "object",
  "required": [
    "stone"
  ],
  "properties": {
    "stone": {
      "type": "number",
      "minimum": 0,
      "description": "Whole or decimal stones"
    },
    "pounds": {
      "type": "number",
      "maximum": 13.99,
      "minimum": 0,
      "description": "Extra pounds on top of the stones (0 to 13.99, optional)"
    }
  }
}

{
  "type": "object",
  "required": [
    "salary",
    "plan"
  ],
  "properties": {
    "plan": {
      "enum": [
        "p1",
        "p2",
        "p4",
        "p5",
        "pg"
      ],
      "type": "string",
      "description": "Repayment plan"
    },
    "salary": {
      "type": "number",
      "maximum": 10000000,
      "minimum": 0,
      "description": "Annual salary in GBP"
    },
    "addPostgraduate": {
      "type": "boolean",
      "default": false,
      "description": "Add a Postgraduate Loan on top of an undergraduate plan (ignored when plan is pg; default false)"
    }
  }
}

{
  "type": "object",
  "required": [
    "salary"
  ],
  "properties": {
    "salary": {
      "type": "number",
      "maximum": 10000000,
      "minimum": 0,
      "description": "Annual gross salary in GBP"
    }
  }
}

{
  "type": "object",
  "required": [
    "spread"
  ],
  "properties": {
    "spread": {
      "enum": [
        "daily",
        "past-present-future",
        "situation",
        "decision",
        "relationship",
        "career",
        "celtic"
      ],
      "type": "string",
      "description": "Which spread to draw"
    },
    "reversed": {
      "type": "boolean",
      "description": "Allow reversed cards (default true)"
    }
  }
}

{
  "type": "object",
  "properties": {
    "mode": {
      "enum": [
        "generate",
        "validate"
      ],
      "type": "string",
      "default": "generate",
      "description": "Generate test numbers, or validate a supplied number (default generate)"
    },
    "brand": {
      "enum": [
        "visa",
        "mastercard",
        "amex",
        "discover"
      ],
      "type": "string",
      "default": "visa",
      "description": "Card brand to generate (default visa)"
    },
    "count": {
      "type": "integer",
      "default": 10,
      "maximum": 50,
      "minimum": 1,
      "description": "How many numbers to generate, 1 to 50 (default 10)"
    },
    "number": {
      "type": "string",
      "description": "For validate mode: the card number to check (spaces and dashes are ignored)"
    }
  }
}

{
  "type": "object",
  "required": [
    "text",
    "count"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to repeat"
    },
    "count": {
      "type": "integer",
      "maximum": 10000,
      "minimum": 1,
      "description": "How many times to repeat it (1 to 10000)"
    },
    "numbering": {
      "type": "boolean",
      "default": false,
      "description": "Prefix each repeat with a number, e.g. '1. ' (default false)"
    },
    "separator": {
      "enum": [
        "none",
        "space",
        "newline",
        "comma",
        "custom"
      ],
      "type": "string",
      "default": "none",
      "description": "How to join the repeats (default none)"
    },
    "customSeparator": {
      "type": "string",
      "description": "The separator string to use when separator is 'custom'"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "mode": {
            "const": "delimiter"
          }
        }
      },
      "then": {
        "required": [
          "delimiter"
        ]
      }
    }
  ],
  "required": [
    "text"
  ],
  "properties": {
    "mode": {
      "enum": [
        "length",
        "delimiter"
      ],
      "type": "string",
      "default": "length",
      "description": "'length' splits by character size (default), 'delimiter' splits at a delimiter"
    },
    "size": {
      "type": "integer",
      "default": 280,
      "minimum": 10,
      "description": "Maximum characters per block for length mode (at least 10, default 280)"
    },
    "text": {
      "type": "string",
      "description": "The text to split"
    },
    "numbered": {
      "type": "boolean",
      "default": false,
      "description": "Add ' n/total' numbering to each block in length mode (default false)"
    },
    "delimiter": {
      "type": "string",
      "minLength": 1,
      "description": "The delimiter for delimiter mode; \\n and \\t are interpreted as newline and tab"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "lines": {
      "type": "integer",
      "default": 1,
      "maximum": 10,
      "minimum": 1,
      "description": "How many lines to generate, 1 to 10 (default 1)"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "hours1": {
      "type": "number",
      "default": 0,
      "minimum": 0,
      "description": "Hours of the first duration (default 0)"
    },
    "hours2": {
      "type": "number",
      "default": 0,
      "minimum": 0,
      "description": "Hours of the second duration (default 0)"
    },
    "minutes1": {
      "type": "number",
      "default": 0,
      "minimum": 0,
      "description": "Minutes of the first duration (default 0)"
    },
    "minutes2": {
      "type": "number",
      "default": 0,
      "minimum": 0,
      "description": "Minutes of the second duration (default 0)"
    },
    "operation": {
      "enum": [
        "add",
        "subtract"
      ],
      "type": "string",
      "default": "add",
      "description": "Add or subtract the second duration from the first (default 'add')"
    }
  }
}

{
  "type": "object",
  "required": [
    "date",
    "time",
    "fromZone",
    "toZone"
  ],
  "properties": {
    "date": {
      "type": "string",
      "format": "date",
      "description": "The date in the source zone, YYYY-MM-DD format"
    },
    "time": {
      "type": "string",
      "format": "time",
      "description": "The time in the source zone, 24-hour HH:MM format"
    },
    "toZone": {
      "enum": [
        "UTC",
        "Europe/London",
        "Europe/Paris",
        "Europe/Berlin",
        "Europe/Madrid",
        "Europe/Athens",
        "Europe/Moscow",
        "Asia/Dubai",
        "Asia/Kolkata",
        "Asia/Bangkok",
        "Asia/Singapore",
        "Asia/Hong_Kong",
        "Asia/Shanghai",
        "Asia/Tokyo",
        "Australia/Sydney",
        "Pacific/Auckland",
        "America/New_York",
        "America/Chicago",
        "America/Denver",
        "America/Los_Angeles",
        "America/Sao_Paulo"
      ],
      "type": "string",
      "description": "Target IANA time zone, e.g. America/New_York"
    },
    "fromZone": {
      "enum": [
        "UTC",
        "Europe/London",
        "Europe/Paris",
        "Europe/Berlin",
        "Europe/Madrid",
        "Europe/Athens",
        "Europe/Moscow",
        "Asia/Dubai",
        "Asia/Kolkata",
        "Asia/Bangkok",
        "Asia/Singapore",
        "Asia/Hong_Kong",
        "Asia/Shanghai",
        "Asia/Tokyo",
        "Australia/Sydney",
        "Pacific/Auckland",
        "America/New_York",
        "America/Chicago",
        "America/Denver",
        "America/Los_Angeles",
        "America/Sao_Paulo"
      ],
      "type": "string",
      "description": "Source IANA time zone, e.g. Europe/London"
    }
  }
}

{
  "type": "object",
  "required": [
    "bill"
  ],
  "properties": {
    "bill": {
      "type": "number",
      "description": "The bill amount before tip"
    },
    "split": {
      "type": "integer",
      "default": 1,
      "minimum": 1,
      "description": "Number of people to split between (default 1)"
    },
    "tipPercent": {
      "type": "number",
      "default": 12.5,
      "minimum": 0,
      "description": "Tip as a percentage (default 12.5)"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "a": {
      "type": "number",
      "description": "Side a, the opposite (greater than 0)",
      "exclusiveMinimum": 0
    },
    "b": {
      "type": "number",
      "description": "Side b, the adjacent (greater than 0)",
      "exclusiveMinimum": 0
    },
    "c": {
      "type": "number",
      "description": "Side c, the hypotenuse (greater than 0, must be the longest side)",
      "exclusiveMinimum": 0
    },
    "angleA": {
      "type": "number",
      "description": "Angle A in degrees, strictly between 0 and 90",
      "exclusiveMaximum": 90,
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "a": {
      "type": "integer",
      "maximum": 20,
      "minimum": 0,
      "description": "Number of A grades (0 to 20)"
    },
    "b": {
      "type": "integer",
      "maximum": 20,
      "minimum": 0,
      "description": "Number of B grades (0 to 20)"
    },
    "c": {
      "type": "integer",
      "maximum": 20,
      "minimum": 0,
      "description": "Number of C grades (0 to 20)"
    },
    "d": {
      "type": "integer",
      "maximum": 20,
      "minimum": 0,
      "description": "Number of D grades (0 to 20)"
    },
    "e": {
      "type": "integer",
      "maximum": 20,
      "minimum": 0,
      "description": "Number of E grades (0 to 20)"
    },
    "aStar": {
      "type": "integer",
      "maximum": 20,
      "minimum": 0,
      "description": "Number of A* grades (0 to 20)"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to inspect"
    }
  }
}

{
  "type": "object",
  "required": [
    "items"
  ],
  "properties": {
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "price",
          "quantity",
          "unit"
        ],
        "properties": {
          "unit": {
            "enum": [
              "g",
              "kg",
              "ml",
              "l",
              "each"
            ],
            "type": "string",
            "description": "Unit of the quantity"
          },
          "price": {
            "type": "number",
            "minimum": 0,
            "description": "Price in GBP"
          },
          "quantity": {
            "type": "number",
            "description": "Quantity in the chosen unit (greater than zero)",
            "exclusiveMinimum": 0
          }
        }
      },
      "minItems": 2,
      "description": "The items to compare (at least two)"
    }
  }
}

{
  "type": "object",
  "anyOf": [
    {
      "required": [
        "timestamp"
      ]
    },
    {
      "required": [
        "date"
      ]
    }
  ],
  "required": [],
  "properties": {
    "date": {
      "type": "string",
      "description": "A date as YYYY-MM-DD. Provide this to convert a date to a timestamp."
    },
    "time": {
      "type": "string",
      "description": "Optional time as HH:MM:SS to accompany 'date' (default 00:00:00), in local time."
    },
    "timestamp": {
      "type": "string",
      "description": "A Unix timestamp in seconds or milliseconds (may be negative). Provide this to convert a timestamp to a date."
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to flip upside down"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "mode": {
      "enum": [
        "component",
        "uri"
      ],
      "type": "string",
      "default": "component",
      "description": "'component' for a single value, 'uri' for a whole URL (default 'component')"
    },
    "text": {
      "type": "string",
      "minLength": 1,
      "description": "The text or URL to encode or decode"
    },
    "action": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "default": "encode",
      "description": "Whether to encode or decode (default 'encode')"
    }
  }
}

{
  "type": "object",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "description": "The URL to parse"
    }
  }
}

{
  "type": "object",
  "required": [
    "ua"
  ],
  "properties": {
    "ua": {
      "type": "string",
      "minLength": 1,
      "description": "The user agent string to parse"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "count": {
      "type": "integer",
      "default": 6,
      "maximum": 50,
      "minimum": 1,
      "description": "How many usernames to generate, 1 to 50 (default 6)"
    },
    "addNumbers": {
      "type": "boolean",
      "default": false,
      "description": "Append a two-digit number to each name (default false)"
    }
  }
}

{
  "type": "object",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "description": "The base URL to tag (https:// assumed if no scheme given)"
    },
    "utm_term": {
      "type": "string",
      "description": "Paid keyword term (optional)"
    },
    "utm_medium": {
      "type": "string",
      "description": "The marketing medium, e.g. email"
    },
    "utm_source": {
      "type": "string",
      "description": "Where the traffic comes from, e.g. newsletter"
    },
    "utm_content": {
      "type": "string",
      "description": "Content variant, e.g. button vs text link (optional)"
    },
    "utm_campaign": {
      "type": "string",
      "description": "The campaign name"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "count": {
      "type": "integer",
      "default": 1,
      "maximum": 100,
      "minimum": 1,
      "description": "How many UUIDs to generate, 1 to 100 (default 1)"
    }
  }
}

{
  "type": "object",
  "required": [
    "amount",
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "add",
        "remove"
      ],
      "type": "string",
      "description": "'add' VAT to a net amount, or 'remove' VAT from a gross amount"
    },
    "rate": {
      "type": "number",
      "default": 20,
      "maximum": 100,
      "minimum": 0,
      "description": "VAT rate as a percentage (default 20)"
    },
    "amount": {
      "type": "number",
      "description": "The money amount"
    }
  }
}

{
  "type": "object",
  "required": [
    "key",
    "text"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "The keyword (only its A to Z letters are used)"
    },
    "mode": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "default": "encode",
      "description": "'encode' to apply the cipher, 'decode' to reverse it (default encode)"
    },
    "text": {
      "type": "string",
      "description": "The text to transform"
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "enum": [
        "ml",
        "l",
        "ukpt",
        "ukgal",
        "usgal",
        "ukfloz",
        "usfloz",
        "m3"
      ],
      "type": "string",
      "description": "Unit to convert to"
    },
    "from": {
      "enum": [
        "ml",
        "l",
        "ukpt",
        "ukgal",
        "usgal",
        "ukfloz",
        "usfloz",
        "m3"
      ],
      "type": "string",
      "description": "Unit to convert from"
    },
    "value": {
      "type": "number",
      "minimum": 0,
      "description": "The volume value to convert"
    }
  }
}

{
  "type": "object",
  "allOf": [
    {
      "if": {
        "properties": {
          "units": {
            "const": "metric"
          }
        }
      },
      "then": {
        "required": [
          "weightKg"
        ]
      }
    }
  ],
  "required": [
    "units"
  ],
  "properties": {
    "hot": {
      "type": "boolean",
      "default": false,
      "description": "Add 500 ml for hot conditions. Default false"
    },
    "units": {
      "enum": [
        "metric",
        "imperial"
      ],
      "type": "string",
      "description": "'metric' (kg) or 'imperial' (stone and pounds)"
    },
    "activity": {
      "enum": [
        "sedentary",
        "light",
        "moderate",
        "active",
        "very_active"
      ],
      "type": "string",
      "default": "sedentary",
      "description": "Activity level, default 'sedentary'"
    },
    "weightKg": {
      "type": "number",
      "maximum": 500,
      "description": "Weight in kilograms (metric)",
      "exclusiveMinimum": 0
    },
    "weightStone": {
      "type": "number",
      "minimum": 0,
      "description": "Whole stone part of weight (imperial)"
    },
    "weightPounds": {
      "type": "number",
      "minimum": 0,
      "description": "Pounds part of weight (imperial)"
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "date": {
      "type": "string",
      "format": "date",
      "description": "Optional date in YYYY-MM-DD format (defaults to today)"
    }
  }
}

{
  "type": "object",
  "required": [
    "value",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "enum": [
        "g",
        "kg",
        "oz",
        "lb",
        "st"
      ],
      "type": "string",
      "description": "Unit to convert to"
    },
    "from": {
      "enum": [
        "g",
        "kg",
        "oz",
        "lb",
        "st"
      ],
      "type": "string",
      "description": "Unit to convert from"
    },
    "value": {
      "type": "number",
      "minimum": 0,
      "description": "The weight value to convert"
    }
  }
}

{
  "type": "object",
  "required": [
    "items"
  ],
  "properties": {
    "items": {
      "type": "array",
      "maxItems": 100,
      "minItems": 2,
      "description": "The list of names or options on the wheel (at least two)"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to analyse"
    }
  }
}

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to analyse"
    },
    "ignoreStopwords": {
      "type": "boolean",
      "default": false,
      "description": "Ignore common words such as the, and, of, to (default false)"
    }
  }
}

{
  "type": "object",
  "required": [
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "type": "string",
      "format": "date",
      "description": "End date in YYYY-MM-DD format"
    },
    "from": {
      "type": "string",
      "format": "date",
      "description": "Start date in YYYY-MM-DD format"
    },
    "bankHolidays": {
      "type": "boolean",
      "default": true,
      "description": "Exclude England and Wales bank holidays as well as weekends (default true)"
    }
  }
}

{
  "type": "object",
  "required": [
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "would-you-rather",
        "icebreaker",
        "this-or-that"
      ],
      "type": "string",
      "description": "Which list to draw from"
    },
    "count": {
      "type": "integer",
      "default": 1,
      "maximum": 20,
      "minimum": 1,
      "description": "How many to draw, 1 to 20 (default 1)"
    },
    "category": {
      "type": "string",
      "description": "Optional category filter (would-you-rather: silly, food, travel, work, deep, kids; icebreaker: work, party, deep, kids). Omit for all."
    }
  }
}

{
  "type": "object",
  "required": [],
  "properties": {
    "allowMaybe": {
      "type": "boolean",
      "default": false,
      "description": "Include 'maybe' as a possible answer (default false)"
    }
  }
}

{
  "type": "object",
  "required": [
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "hide",
        "reveal",
        "clean"
      ],
      "type": "string",
      "description": "hide, reveal or clean"
    },
    "text": {
      "type": "string",
      "description": "Reveal and clean modes: the text to inspect"
    },
    "cover": {
      "type": "string",
      "description": "Hide mode: the visible cover text that carries the message"
    },
    "secret": {
      "type": "string",
      "description": "Hide mode: the message to hide"
    },
    "spread": {
      "type": "boolean",
      "description": "Hide mode: distribute the invisible run evenly between words instead of placing it after the first word"
    }
  }
}