HelpySelf

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "birth"
  ],
  "properties": {
    "asOf": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "The date to measure the age at, YYYY-MM-DD. Omitted, the server's own UTC date is used, which can be a day out for the caller near midnight, so pass it when the exact day matters. Must not be before the birth date. The response echoes the date it used."
    },
    "birth": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "Date of birth as YYYY-MM-DD. Read as a calendar date with no time zone, so the answer is the same wherever it is asked from."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "search": {
      "type": "string",
      "default": "",
      "maxLength": 100,
      "description": "What to look up: a single character (\"A\"), a decimal code (\"65\"), hex (\"0x41\", \"U+0041\", \"\\x41\"), binary (\"0b01000001\"), octal (\"0o101\"), an HTML entity (\"&\"), an abbreviation (\"LF\") or part of a name (\"line feed\", \"sep\"). Numbers return one entry; names return every match, best first. Plain digits are always decimal. Empty (the default) returns the whole table."
    },
    "includeExtended": {
      "type": "boolean",
      "default": false,
      "description": "Also include codes 128 to 255, read as ISO-8859-1 (Latin-1). ASCII proper stops at 127, so a search for a higher code finds nothing unless this is true."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 120000,
      "minLength": 40,
      "description": "The document's plain text, as extracted from the PDF, not the file itself. It is sent to a language model, which returns the personal names and postal addresses found in it, each exactly as written; the caller maps them back to positions. Emails, phone and card numbers are not returned, since patterns catch those locally. At least 40 characters and at most 120000."
    },
    "language": {
      "type": "string",
      "maxLength": 40,
      "description": "The language the document is most likely in, such as \"Danish\", passed to the model as a hint because it changes what a name looks like. A hint only: a wrong guess does not stop the text being read, and omitting it is fine."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "numbers"
  ],
  "properties": {
    "numbers": {
      "type": "string",
      "maxLength": 200000,
      "minLength": 1,
      "description": "The list of numbers as one string, separated by commas, spaces, line breaks or anything else that is not a digit, sign or decimal point. Use a decimal point, never a decimal comma: \"1,5\" is read as two numbers. Anything unparseable is skipped, and at least one number must remain. Returns mean, median, mode, range and both standard deviations."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 80,
      "minLength": 1,
      "description": "What to encode. For ean13, upca and ean8 this is digits only: 12, 11 or 7 of them and the check digit is worked out, or one more and it is verified (a wrong one is refused rather than drawn). For code128 it is any printable ASCII up to 80 characters."
    },
    "scale": {
      "type": "integer",
      "default": 3,
      "maximum": 12,
      "minimum": 1,
      "description": "Width of the narrowest bar in pixels; every other width and the quiet zones are multiples of it, so this sets the overall size. 3 is about right for a screen."
    },
    "height": {
      "type": "integer",
      "default": 80,
      "maximum": 400,
      "minimum": 20,
      "description": "Height of the bars in pixels. The printed number and the longer guard bars add to the total height of the SVG when showText is true."
    },
    "showText": {
      "type": "boolean",
      "default": true,
      "description": "Print the encoded value underneath the bars, as a retail barcode always does. False gives bars only."
    },
    "symbology": {
      "enum": [
        "ean13",
        "upca",
        "ean8",
        "code128"
      ],
      "type": "string",
      "default": "ean13",
      "description": "Which barcode standard to draw. ean13 (13 digits, the retail default worldwide), upca (12 digits, North American retail), ean8 (8 digits, small packaging), code128 (letters, digits and punctuation, for labels and logistics)."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 35000000,
      "minLength": 1,
      "description": "The image file's bytes, base64-encoded: JPEG, PNG, WebP, GIF or BMP. SVG is refused here (the server cannot rasterise it); convert it to PNG first."
    },
    "type": {
      "type": "string",
      "maxLength": 100,
      "description": "The MIME type of the bytes, such as image/png. Optional and only used to reject something that is plainly not an image; the format is otherwise read from the bytes."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 1000000,
      "minLength": 1,
      "description": "The text to encode, or the Base64 to decode, depending on action. Encoding goes through UTF-8 first, so accents, emoji and CJK survive. Decoding accepts standard or URL-safe Base64, with or without padding, and ignores whitespace."
    },
    "action": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "default": "encode",
      "description": "encode turns text into Base64; decode turns Base64 back into UTF-8 text. Defaults to encode."
    },
    "urlSafe": {
      "type": "boolean",
      "default": false,
      "description": "When encoding, use the URL-safe alphabet (RFC 4648 section 5): + and / become - and _, and the = padding is dropped, as in JWTs. Ignored when decoding, which detects either alphabet."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 100000,
      "minLength": 1,
      "description": "Plain text, or bytes written as binary, hex, decimal or octal. Groups may be separated by spaces or commas; hex also accepts 0x prefixes and unspaced pairs. Every other representation of the same bytes comes back at once, so there is no direction to choose. Text is treated as UTF-8, so \"é\" is two bytes."
    },
    "readAs": {
      "enum": [
        "auto",
        "text",
        "binary",
        "hex",
        "decimal",
        "octal"
      ],
      "type": "string",
      "default": "auto",
      "description": "How to read input. auto (the default) works it out: only 0s and 1s in whole bytes is binary, hex digits with a letter or 0x is hex, several zero-padded pairs is hex, several numbers up to 255 is decimal, anything else is text. Octal is never guessed, since \"17\" is valid octal and decimal, so name it explicitly. Byte values over 255 are refused."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "weight"
  ],
  "properties": {
    "feet": {
      "type": "number",
      "maximum": 9,
      "minimum": 0,
      "description": "The whole-feet part of the height. Imperial only; ignored when metric. Either feet or inches may be left out, so 6 ft with no inches works."
    },
    "units": {
      "enum": [
        "metric",
        "imperial"
      ],
      "type": "string",
      "default": "metric",
      "description": "metric (the default) reads weight as kg and height as cm; imperial reads weight as lb and height as feet plus inches. Also sets the unit of the healthy range returned."
    },
    "height": {
      "type": "number",
      "maximum": 300,
      "description": "Height in centimetres. Required when units is metric and ignored when imperial, which takes feet and inches instead.",
      "exclusiveMinimum": 0
    },
    "inches": {
      "type": "number",
      "maximum": 11.99,
      "minimum": 0,
      "description": "The inches part of the height, added to feet. Imperial only; ignored when metric."
    },
    "weight": {
      "type": "number",
      "maximum": 1500,
      "description": "Body weight, in kilograms when units is metric and in pounds when imperial. The healthy-weight range in the response comes back in the same unit.",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "title",
    "players"
  ],
  "properties": {
    "draw": {
      "enum": [
        "seeded",
        "shuffled"
      ],
      "type": "string",
      "default": "seeded",
      "description": "`seeded` treats the order given as the rankings: the first two can only meet in the final and byes go to the top. `shuffled` draws at random, which is what an office sweepstake wants. Either way the order is fixed once the bracket exists."
    },
    "title": {
      "type": "string",
      "maxLength": 80,
      "minLength": 1,
      "description": "The tournament's name, shown as the page heading. Up to 80 characters."
    },
    "players": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 40,
        "minLength": 1,
        "description": "One entrant's name, as it is shown."
      },
      "maxItems": 64,
      "minItems": 4,
      "description": "Everybody in the draw, 4 to 64. Any number works — one that is not a power of two gets byes in the first round, placed against the top seeds so no bye faces another and both halves play the same number of rounds. Names are compared case-insensitively, so the same name twice is refused as a typo."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 20000,
      "minLength": 1,
      "description": "Print text to transcribe into Grade 1 braille, or braille (the Unicode braille block, U+2800 to U+28FF) to turn back into print."
    },
    "direction": {
      "enum": [
        "auto",
        "toBraille",
        "toText"
      ],
      "type": "string",
      "default": "auto",
      "description": "Which way to translate. \"auto\" reads braille back into print and transcribes anything else; \"toBraille\" and \"toText\" force one direction."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "type",
    "data",
    "maxEdge"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 70000000,
      "minLength": 1,
      "description": "The image file's bytes, base64-encoded."
    },
    "name": {
      "type": "string",
      "default": "image.png",
      "maxLength": 255,
      "description": "The original filename. Echoed back unchanged as the result's name."
    },
    "type": {
      "enum": [
        "image/jpeg",
        "image/png",
        "image/webp"
      ],
      "type": "string",
      "description": "The MIME type of the bytes in data: JPEG, PNG or WebP. Also the output type when format is keep."
    },
    "format": {
      "enum": [
        "keep",
        "image/jpeg",
        "image/webp",
        "image/png"
      ],
      "type": "string",
      "default": "keep",
      "description": "The output format. keep (the default) re-encodes in the same type as the input; the others convert. JPEG has no transparency, so transparent areas are flattened onto white."
    },
    "maxEdge": {
      "type": "integer",
      "maximum": 10000,
      "minimum": 16,
      "description": "The longest side of the result in pixels. The image is scaled down to fit inside this on its longer edge, keeping its aspect ratio. Never enlarges: an image already within the bound is returned as it is, with unchanged: true."
    },
    "quality": {
      "type": "number",
      "default": 0.82,
      "maximum": 1,
      "minimum": 0.1,
      "description": "Encoder quality for JPEG and WebP, 0.1 (smallest) to 1 (largest). Has no effect on PNG, which is lossless."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "startDate",
    "days"
  ],
  "properties": {
    "days": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991,
      "description": "How many working days (Monday to Friday, minus holidays) to move. Positive counts forward, negative counts back; zero is refused. More than 5200 either way is refused as too far."
    },
    "holidays": {
      "type": "array",
      "items": {
        "type": "string",
        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
        "description": "A date to skip, YYYY-MM-DD."
      },
      "maxItems": 200,
      "description": "Dates to skip in addition to Saturdays and Sundays, YYYY-MM-DD each. No public holidays are assumed for any country, so pass the ones that apply. Omitted, only weekends are skipped. Those that fell on the path are listed in the response."
    },
    "startDate": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "The date to count from, YYYY-MM-DD. Counting begins the day after it, so one working day from a Friday is the Monday. It may itself be a weekend or holiday; the response says whether it was a working day."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "sex",
    "age",
    "weightKg",
    "heightCm"
  ],
  "properties": {
    "age": {
      "type": "integer",
      "maximum": 120,
      "minimum": 1,
      "description": "Age in years. The equation was fitted on adults, so under 18 or over 100 the answer is still computed but reported as reliable: false."
    },
    "sex": {
      "enum": [
        "female",
        "male"
      ],
      "type": "string",
      "description": "Enters the Mifflin-St Jeor equation as a constant, and sets the lowest intake the tool will suggest: 1,200 kcal a day for female, 1,500 for male."
    },
    "activity": {
      "enum": [
        "sedentary",
        "light",
        "moderate",
        "active",
        "athlete"
      ],
      "type": "string",
      "default": "sedentary",
      "description": "How active a typical week is, multiplying resting metabolism to get maintenance calories: sedentary (little or no exercise, x1.2, the default), light (x1.375), moderate (x1.55), active (x1.725), athlete (very hard daily training, x1.9)."
    },
    "heightCm": {
      "type": "number",
      "maximum": 272,
      "minimum": 50,
      "description": "Height in centimetres. Under 120 cm the answer is marked unreliable."
    },
    "weightKg": {
      "type": "number",
      "maximum": 500,
      "minimum": 1,
      "description": "Body weight in kilograms. Under 30 kg the answer is marked unreliable."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 100000,
      "minLength": 1,
      "description": "The text to convert. It may already be in any case: camelCase, snake_case, kebab-case, acronyms like HTTPServer and digits are all split into words before being rebuilt."
    },
    "target": {
      "enum": [
        "camel",
        "pascal",
        "snake",
        "constant",
        "kebab",
        "title",
        "sentence",
        "upper",
        "lower"
      ],
      "type": "string",
      "description": "The case to produce: camel (helloWorld), pascal (HelloWorld), snake (hello_world), constant (HELLO_WORLD), kebab (hello-world), title (Hello World, small words like \"of\" kept lower unless first or last), sentence (first letter of each sentence capitalised, punctuation kept), upper or lower (the whole text, punctuation kept). Omit to get every case at once as a list."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data",
    "expected"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 35000000,
      "minLength": 1,
      "description": "The file's bytes, base64-encoded. They are hashed with whichever algorithm expected implies and compared; the response is a match boolean plus both digests."
    },
    "expected": {
      "type": "string",
      "maxLength": 4096,
      "minLength": 1,
      "description": "The published checksum, pasted as found: bare hex in either case, a whole SHA256SUMS line with the filename, a sha256: prefix as registries use, or a sha256-<base64> integrity value. The algorithm (SHA-1, SHA-256, SHA-384 or SHA-512) is read from the prefix or the digest length, never chosen. MD5 is refused."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "count": {
      "type": "integer",
      "default": 1,
      "maximum": 1000,
      "minimum": 1,
      "description": "How many times to flip, 1 to 1000. Every flip comes back in order, with a heads and tails tally beside them."
    },
    "headsPercent": {
      "type": "number",
      "default": 50,
      "maximum": 100,
      "minimum": 0,
      "description": "Chance of heads on each flip, as a percentage. 50 is a fair coin; 12.5 is honoured exactly rather than rounded to a whole percent."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "color"
  ],
  "properties": {
    "color": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1,
      "description": "The colour to convert, in any CSS form: #rgb, #rrggbb, #rrggbbaa, rgb()/rgba(), hsl()/hsla() or a colour name like teal. It comes back as hex, rgb and hsl, with the channels as numbers and a black-or-white text colour that reads on it."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "listA",
    "listB"
  ],
  "properties": {
    "trim": {
      "type": "boolean",
      "default": true,
      "description": "Ignore space at either end of a line when comparing, so 'Alice ' and 'Alice' match. On by default."
    },
    "listA": {
      "type": "string",
      "maxLength": 500000,
      "description": "The first list, one entry per line. Order does not matter: each side is treated as a set, and the answer is what is only in A, only in B, and in both."
    },
    "listB": {
      "type": "string",
      "maxLength": 500000,
      "description": "The second list, one entry per line, compared against listA the same way."
    },
    "ignoreCase": {
      "type": "boolean",
      "default": true,
      "description": "Treat Alice and alice as the same entry. On by default. The output keeps whichever spelling appeared first rather than lower-casing it."
    },
    "ignoreBlank": {
      "type": "boolean",
      "default": true,
      "description": "Drop empty lines rather than counting them as entries. On by default; off, a blank line on both sides shows up under both."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "type",
    "data",
    "targetKb"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 70000000,
      "minLength": 1,
      "description": "The image file itself, base64-encoded (no data: prefix). The result's data is the compressed file in the same encoding."
    },
    "name": {
      "type": "string",
      "default": "image.jpg",
      "maxLength": 255,
      "description": "The file name, echoed back in the response so a caller can keep it with the result. It does not decide the format; type does."
    },
    "type": {
      "enum": [
        "image/jpeg",
        "image/png",
        "image/webp"
      ],
      "type": "string",
      "description": "The MIME type of the bytes in data. A JPEG is re-encoded as JPEG; PNG and WebP input both come back as WebP."
    },
    "targetKb": {
      "type": "integer",
      "maximum": 25000,
      "minimum": 1,
      "description": "The size the output must not exceed, in kilobytes of 1,024 bytes, as upload limits mean it. The highest quality that fits is found by re-encoding; if none does, the response says so and suggests a scale factor to shrink the pixels by instead."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "foreground",
    "background"
  ],
  "properties": {
    "target": {
      "type": "number",
      "default": 4.5,
      "maximum": 21,
      "minimum": 1,
      "description": "The contrast ratio the suggestion must reach. Only used when suggest is true. 4.5 is WCAG AA for normal text, 3 is AA for large text, 7 is AAA."
    },
    "suggest": {
      "type": "boolean",
      "default": false,
      "description": "Also return a suggestion: the foreground nudged lighter or darker until it clears target, as hex, or null if even black or white would not. Off by default."
    },
    "background": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1,
      "description": "The colour behind the text, in the same forms as foreground."
    },
    "foreground": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1,
      "description": "The text colour, as hex, rgb(), hsl() or a CSS colour name. A translucent colour is composited over the background before the ratio is taken."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "foreground",
    "background"
  ],
  "properties": {
    "level": {
      "enum": [
        "AA",
        "AA_LARGE",
        "AAA",
        "AAA_LARGE"
      ],
      "type": "string",
      "default": "AA",
      "description": "The WCAG grade to reach. AA is normal body text at 4.5:1, AA_LARGE is large text at 3:1, AAA is 7:1 and AAA_LARGE is 4.5:1. Defaults to AA."
    },
    "adjust": {
      "enum": [
        "foreground",
        "background",
        "either"
      ],
      "type": "string",
      "default": "either",
      "description": "Which colour may change. Only its lightness moves; hue and saturation are kept. 'either' tries both and returns the smallest change first. Defaults to either."
    },
    "background": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1,
      "description": "The colour behind the text, in the same forms as foreground."
    },
    "foreground": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1,
      "description": "The text colour, as hex, rgb(), hsl() or a CSS colour name."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "palette"
  ],
  "properties": {
    "level": {
      "enum": [
        "AA",
        "AA_LARGE",
        "AAA",
        "AAA_LARGE"
      ],
      "type": "string",
      "default": "AA",
      "description": "The WCAG grade a pairing must clear to count as passing: AA is 4.5:1, AA_LARGE is 3:1, AAA is 7:1, AAA_LARGE is 4.5:1. Every cell still reports its own ratio and grade; this only decides the pass count. Defaults to AA."
    },
    "palette": {
      "type": "string",
      "maxLength": 4000,
      "minLength": 1,
      "description": "The colours to check against each other, as hex, rgb(), hsl() or CSS colour names, separated by newlines, commas or spaces. CSS custom-property names are ignored, duplicates are dropped, and 2 to 24 distinct colours are needed."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "maxLength": 2048,
      "minLength": 1,
      "description": "The public website to check, for example https://example.com. A bare hostname is read as https. The page is fetched as a normal browser would and every Set-Cookie header it returns is parsed and judged. Private, loopback and non-http addresses are refused."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "hours": {
      "type": "integer",
      "default": 0,
      "maximum": 24,
      "minimum": 0,
      "description": "The hours part of the duration. The three parts are added together and capped at 24 hours in total, then returned as milliseconds, as h:mm:ss text and as parts."
    },
    "minutes": {
      "type": "integer",
      "default": 5,
      "maximum": 59,
      "minimum": 0,
      "description": "The minutes part of the duration. Defaults to 5, so an empty request is 05:00."
    },
    "seconds": {
      "type": "integer",
      "default": 0,
      "maximum": 59,
      "minimum": 0,
      "description": "The seconds part of the duration."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "expression"
  ],
  "properties": {
    "count": {
      "type": "integer",
      "default": 5,
      "maximum": 20,
      "minimum": 1,
      "description": "How many upcoming runs to list, strictly after now, each as a wall-clock ISO string without an offset plus a readable form. Defaults to 5."
    },
    "timezone": {
      "type": "string",
      "default": "UTC",
      "maxLength": 64,
      "description": "The IANA time zone the schedule is read in, such as Europe/Copenhagen. Cron means wall-clock time, so the run times change with it. Defaults to UTC, and an unrecognised name falls back to UTC."
    },
    "expression": {
      "type": "string",
      "maxLength": 200,
      "minLength": 1,
      "description": "A five-field crontab expression (minute, hour, day of month, month, day of week) such as '*/15 9-17 * * MON-FRI', or a shorthand like @daily or @hourly. Names, ranges, lists and steps are accepted; Quartz seconds and L/W/# are not. It comes back explained in words with its next run times."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "amount",
    "fromCurrency",
    "toCurrency"
  ],
  "properties": {
    "amount": {
      "type": "number",
      "description": "How much of fromCurrency to convert, in major units (dollars, not cents). Negative is allowed, since a refund is a conversion too. A plain numeric string such as \"10\" is read as the number."
    },
    "toCurrency": {
      "type": "string",
      "maxLength": 3,
      "minLength": 3,
      "description": "The ISO 4217 code to convert into, such as EUR. The rate used is the ECB cross rate for the day, and the whole day's rate table comes back with the answer."
    },
    "fromCurrency": {
      "type": "string",
      "maxLength": 3,
      "minLength": 3,
      "description": "The ISO 4217 code of the currency the amount is in, such as USD. Case does not matter. Only currencies the European Central Bank quotes daily are known; an unknown code returns an error naming it."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "fromDate",
    "toDate"
  ],
  "properties": {
    "toDate": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "The other date as YYYY-MM-DD. It may be earlier than fromDate: the difference is counted between the two whichever way round, and direction in the response says forward, backward or same."
    },
    "fromDate": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "The first date as YYYY-MM-DD, usually the earlier one. The answer gives years, months and days, the gap in days, the span counting both ends, whole weeks, and Monday-to-Friday working days (public holidays not excluded)."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "day": {
      "type": "integer",
      "default": 25,
      "maximum": 31,
      "minimum": 1,
      "description": "The day of the month. Defaults to the 25th. A day the month never has (30 February) is refused; 29 February counts to the next leap year. Whole calendar days are counted, the day itself is 0, and a date already passed rolls to next year."
    },
    "month": {
      "type": "integer",
      "default": 12,
      "maximum": 12,
      "minimum": 1,
      "description": "The month of the occasion, 1 to 12. Defaults to December. Pass month and day together to count to any yearly date, such as a birthday."
    },
    "today": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "The date to count from, as YYYY-MM-DD in the caller's own calendar. Defaults to today in UTC. The response repeats the date it counted from as countedFrom."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "game"
  ],
  "properties": {
    "game": {
      "type": "string",
      "maxLength": 200,
      "minLength": 1,
      "description": "The game to look up: a name, a Steam store URL or a numeric app id, in one field. A name is matched against every game ever seen in the weekly Steam snapshots, including ones Steam's own search no longer finds, and up to 8 matches come back each with a status of listed, delisted, upcoming, gone or unknown."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "dice": {
      "type": "integer",
      "default": 1,
      "maximum": 100,
      "minimum": 1,
      "description": "How many dice to roll, 1 to 100: the 2 in 2d6+3. Each roll comes back separately along with their subtotal."
    },
    "sides": {
      "type": "integer",
      "default": 6,
      "maximum": 1000,
      "minimum": 2,
      "description": "Faces on each die, 2 to 1000: the 6 in 2d6+3. Every die rolls 1 to this number. Defaults to 6."
    },
    "modifier": {
      "type": "integer",
      "default": 0,
      "maximum": 10000,
      "minimum": -10000,
      "description": "A whole number added once to the total, not to each die: the +3 in 2d6+3. May be negative. Defaults to 0."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 70000000,
      "minLength": 1,
      "description": "The image file as base64: a JPEG, PNG or WebP. The format is detected from the bytes, and files over 50 MB are refused."
    },
    "name": {
      "type": "string",
      "default": "image.jpg",
      "maxLength": 255,
      "description": "A filename echoed back with a strip result. It does not affect what is removed."
    },
    "action": {
      "enum": [
        "inspect",
        "strip"
      ],
      "type": "string",
      "default": "strip",
      "description": "'inspect' lists the metadata found (camera, time, location) without changing the file. 'strip' returns the same image with that metadata removed, losslessly."
    },
    "keepOrientation": {
      "type": "boolean",
      "default": true,
      "description": "Keep the EXIF orientation flag when stripping, so a phone photo does not turn on its side. Set false to remove it with everything else."
    },
    "keepColourProfile": {
      "type": "boolean",
      "default": true,
      "description": "Keep the ICC colour profile when stripping. Set false to remove it too, which can visibly shift the colours on wide-gamut screens."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "type",
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 70000000,
      "minLength": 1,
      "description": "The source image as base64. A square image works best; a non-square one is cropped to a centred square before the sizes are made."
    },
    "name": {
      "type": "string",
      "default": "image.png",
      "maxLength": 255,
      "description": "The source file's name. Informational only; the outputs use fixed favicon names."
    },
    "type": {
      "enum": [
        "image/jpeg",
        "image/png",
        "image/webp"
      ],
      "type": "string",
      "description": "The MIME type of the source image: image/jpeg, image/png or image/webp."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "title",
    "options"
  ],
  "properties": {
    "days": {
      "type": "integer",
      "default": 30,
      "maximum": 180,
      "minimum": 1,
      "description": "How many days the poll link stays open from now. After that it expires."
    },
    "note": {
      "type": "string",
      "maxLength": 400,
      "description": "A line shown under the title to the people answering, such as where to meet."
    },
    "title": {
      "type": "string",
      "maxLength": 120,
      "minLength": 1,
      "description": "The heading on the poll page, shown to everybody who opens the link. 'Coffee with the team', 'Board meeting'."
    },
    "locale": {
      "type": "string",
      "maxLength": 5,
      "description": "The language of the poll page: one of en, de, es, fi, fr, it, nl, pl. Anything else, or nothing, gives English."
    },
    "options": {
      "type": "array",
      "items": {
        "anyOf": [
          {
            "type": "object",
            "required": [
              "date"
            ],
            "properties": {
              "date": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                "description": "The calendar date of this option, as YYYY-MM-DD."
              },
              "time": {
                "type": "string",
                "pattern": "^\\d{2}:\\d{2}$",
                "description": "The start time on that date, as 24-hour HH:MM. Leave it out to offer the whole day."
              }
            },
            "description": "One time to vote on: a date, and optionally a time on it."
          },
          {
            "type": "string",
            "pattern": "^\\d{4}-\\d{2}-\\d{2}(?:[T ]\\d{2}:\\d{2}(?::\\d{2})?)?$",
            "description": "The same option written out: \"2026-10-20 14:00\", or \"2026-10-20\" for the whole day."
          }
        ]
      },
      "maxItems": 366,
      "minItems": 2,
      "description": "The times people choose between, at least 2 and at most 366. Each one is either an object {date, time} or a plain string like \"2026-10-20 14:00\" or \"2026-10-20\" for a whole day. Duplicates are refused; they are sorted chronologically for the page."
    },
    "timezone": {
      "type": "string",
      "maxLength": 64,
      "description": "The IANA time zone the option times are written in, e.g. 'Europe/Berlin', so the page can say so. Omit it, or give an unknown zone, and the times are shown as written with no zone claimed."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "fractionA",
    "operator",
    "fractionB"
  ],
  "properties": {
    "operator": {
      "enum": [
        "+",
        "-",
        "*",
        "/"
      ],
      "type": "string",
      "description": "The arithmetic to apply: add, subtract, multiply or divide fractionA by fractionB."
    },
    "fractionA": {
      "type": "string",
      "maxLength": 40,
      "minLength": 1,
      "description": "The left operand as text: a fraction '3/4', a mixed number '2 3/4' or a whole number '5'. Negative values are allowed; decimals are not."
    },
    "fractionB": {
      "type": "string",
      "maxLength": 40,
      "minLength": 1,
      "description": "The right operand, in the same forms as fractionA. Dividing by zero is refused."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 80,
      "minLength": 1,
      "description": "The list's title, in the collector's own words: 'PS2 for sale', 'Boxed SNES'."
    },
    "note": {
      "type": "string",
      "maxLength": 400,
      "description": "A line shown under the title: what the list is for, or what its prices mean."
    },
    "shared": {
      "type": "boolean",
      "default": false,
      "description": "Whether the public share link works for anybody who has it. Off by default, so the list is private to its owner until this is set."
    },
    "console": {
      "type": "string",
      "maxLength": 40,
      "description": "The console the list is for, by its usual name ('PS2', 'SNES', 'Mega Drive', 'Game Boy Advance'); matching ignores case. It narrows the game search when adding. A name not on the known list is refused; omit it for a mixed list."
    },
    "folderId": {
      "type": "string",
      "maxLength": 64,
      "description": "The id of one of the caller's own folders to file the list under. An unknown id, or another account's folder, is refused."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "gif"
  ],
  "properties": {
    "gif": {
      "type": "string",
      "maxLength": 40000000,
      "minLength": 1,
      "description": "The animated or still GIF file as base64. The result is also a GIF."
    },
    "name": {
      "type": "string",
      "default": "image.gif",
      "maxLength": 200,
      "description": "The input filename. The result is named after it with '-small.gif' appended to the stem."
    },
    "scale": {
      "type": "number",
      "default": 1,
      "maximum": 1,
      "minimum": 0.1,
      "description": "A size factor per edge, 1 being the original size. Over the API only 1 is accepted; any other value is refused, because scaling happens in the browser tool alone."
    },
    "colours": {
      "type": "integer",
      "default": 128,
      "maximum": 9007199254740991,
      "minimum": -9007199254740991,
      "description": "Colours in each frame's palette, one of 256, 128, 64, 32, 16. Fewer colours make a smaller file at the cost of banding in gradients."
    },
    "keepEvery": {
      "type": "integer",
      "default": 1,
      "maximum": 10,
      "minimum": 1,
      "description": "Drop frames to shrink the file: 1 keeps every frame, 2 keeps every second one, 3 every third. Each kept frame takes on the delay of the frames dropped after it, so the animation runs for the same time."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "courses"
  ],
  "properties": {
    "courses": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "grade",
          "credits"
        ],
        "properties": {
          "name": {
            "type": "string",
            "maxLength": 120,
            "description": "The course's name, used only to label it in the report."
          },
          "grade": {
            "type": "string",
            "maxLength": 4,
            "minLength": 1,
            "description": "The grade as a letter on the US 4.0 scale ('A', 'B+', 'C-', 'F'; A+ counts as 4.0) or as grade points directly ('3.7'). A number above 5 or an unknown letter leaves the course out of the average."
          },
          "credits": {
            "type": "number",
            "maximum": 100,
            "minimum": 0,
            "description": "The course's credit hours, which weight its grade in the average. A course with 0 credits is left out rather than counted as zero."
          }
        },
        "description": "One course: its grade and how much it weighs."
      },
      "maxItems": 200,
      "minItems": 1,
      "description": "The courses to average. The GPA is the credit-weighted mean of their grade points."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "stops"
  ],
  "properties": {
    "type": {
      "enum": [
        "linear",
        "radial",
        "conic"
      ],
      "type": "string",
      "default": "linear",
      "description": "The kind of CSS gradient: 'linear' runs in a straight line at the angle, 'radial' spreads out from the centre, 'conic' sweeps round the centre."
    },
    "angle": {
      "type": "number",
      "default": 180,
      "maximum": 360,
      "minimum": -360,
      "description": "Degrees, normalised to 0-359. For linear it is the direction the gradient runs, 0 pointing up and 180 down; for conic it is where the sweep starts. Ignored for radial."
    },
    "shape": {
      "enum": [
        "circle",
        "ellipse"
      ],
      "type": "string",
      "default": "ellipse",
      "description": "For radial gradients only: 'circle' keeps the rings round, 'ellipse' stretches them to the box. Ignored for linear and conic."
    },
    "stops": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "colour"
        ],
        "properties": {
          "colour": {
            "type": "string",
            "maxLength": 64,
            "minLength": 1,
            "description": "Any CSS colour: a hex code, rgb(), hsl() or a named colour."
          },
          "position": {
            "type": "number",
            "maximum": 100,
            "minimum": 0,
            "description": "Where along the gradient this colour sits, as a percentage from 0 to 100. Omit it and CSS spaces the stop evenly between its neighbours."
          }
        },
        "description": "One colour stop."
      },
      "maxItems": 16,
      "minItems": 2,
      "description": "The colours in order, from 2 to 16 of them."
    },
    "repeating": {
      "type": "boolean",
      "default": false,
      "description": "Emit the repeating-* variant, which tiles the gradient over the box instead of stretching it once. Only visible when the stops have explicit positions short of 100."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 1000000,
      "minLength": 1,
      "description": "The text to hash. It is encoded as UTF-8 before hashing, exactly as given."
    },
    "algorithms": {
      "type": "array",
      "items": {
        "enum": [
          "SHA-1",
          "SHA-256",
          "SHA-384",
          "SHA-512"
        ],
        "type": "string",
        "description": "One digest algorithm."
      },
      "default": [
        "SHA-256"
      ],
      "minItems": 1,
      "description": "Which digests to compute, from SHA-1, SHA-256, SHA-384, SHA-512. One hex digest comes back per algorithm named."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "iban"
  ],
  "properties": {
    "iban": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1,
      "description": "The account number to check, written however you have it: 'DK50 0040 0440 1162 43' and 'dk5000400440116243' are the same thing. Spaces, hyphens and case are ignored."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "type",
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 70000000,
      "minLength": 1,
      "description": "The image file as base64, in the format given by type."
    },
    "name": {
      "type": "string",
      "default": "image.png",
      "maxLength": 255,
      "description": "The source filename, echoed back as the result's name."
    },
    "type": {
      "enum": [
        "image/jpeg",
        "image/png",
        "image/webp"
      ],
      "type": "string",
      "description": "The MIME type of the source image: image/jpeg, image/png or image/webp. HEIC, AVIF, TIFF and BMP are not accepted over the API."
    },
    "format": {
      "enum": [
        "auto",
        "image/jpeg",
        "image/webp",
        "image/png"
      ],
      "type": "string",
      "default": "auto",
      "description": "The output format. 'auto' always means WebP, which is usually the smallest. If the result would be no smaller than the input at the same size, the original bytes are returned unchanged."
    },
    "maxEdge": {
      "type": "integer",
      "maximum": 10000,
      "minimum": 16,
      "description": "Shrink the image so its longer side is at most this many pixels, keeping the aspect ratio. Smaller images are left at their size; omit it to keep the dimensions."
    },
    "quality": {
      "type": "number",
      "default": 0.8,
      "maximum": 1,
      "minimum": 0.1,
      "description": "Encoder quality from 0.1 to 1 for JPEG and WebP output; lower means a smaller, softer file. PNG is lossless and ignores it."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 27000000,
      "minLength": 1,
      "description": "The image file as base64, in the format given by type. Send this or fileId, not both. Anything a vision model can read works: a photo of a page, a screenshot, a scan."
    },
    "mode": {
      "enum": [
        "text",
        "markdown",
        "table"
      ],
      "type": "string",
      "default": "text",
      "description": "What to return: 'text' is the words in reading order and nothing else; 'markdown' keeps headings and lists, which suits a document scan; 'table' transcribes a table as CSV."
    },
    "type": {
      "enum": [
        "image/jpeg",
        "image/png",
        "image/webp",
        "image/gif"
      ],
      "type": "string",
      "default": "image/png",
      "description": "The MIME type of the bytes in data: image/jpeg, image/png, image/webp or image/gif. Ignored when fileId is used, since the stored type wins."
    },
    "fileId": {
      "type": "string",
      "format": "uuid",
      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$",
      "description": "The id of an image already uploaded to the caller's account, to read instead of data. Needs a signed-in caller; the upload is consumed by the run. Most scripts should send data instead."
    },
    "language": {
      "type": "string",
      "maxLength": 40,
      "description": "The language the text is most likely in, e.g. 'Danish', as a hint to the model. It is not a constraint: what is actually in the picture is transcribed."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "images"
  ],
  "properties": {
    "images": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "type",
          "data"
        ],
        "properties": {
          "data": {
            "type": "string",
            "maxLength": 30000000,
            "minLength": 1,
            "description": "The image file as base64. A data: URL prefix is tolerated and stripped."
          },
          "name": {
            "type": "string",
            "default": "image.jpg",
            "maxLength": 255,
            "description": "The image's filename. Its extension is a fallback for telling JPEG from PNG."
          },
          "type": {
            "enum": [
              "image/jpeg",
              "image/png"
            ],
            "type": "string",
            "description": "The MIME type of the bytes: image/jpeg or image/png. Only these two can be embedded."
          }
        },
        "description": "One image, which becomes one page."
      },
      "maxItems": 100,
      "minItems": 1,
      "description": "The images in page order, one page each, at most 100 of them."
    },
    "margin": {
      "type": "integer",
      "default": 0,
      "maximum": 144,
      "minimum": 0,
      "description": "White space around the image on 'a4' and 'letter' pages, in PDF points (72 per inch; 144 is two inches). Ignored for 'fit'."
    },
    "pageSize": {
      "enum": [
        "fit",
        "a4",
        "letter"
      ],
      "type": "string",
      "default": "fit",
      "description": "The paper size. 'fit' makes each page exactly the image's own pixel size, with no margins or letterboxing; 'a4' and 'letter' put every image on that fixed page, scaled to fit and centred."
    },
    "orientation": {
      "enum": [
        "portrait",
        "landscape",
        "auto"
      ],
      "type": "string",
      "default": "auto",
      "description": "Page orientation for 'a4' and 'letter': 'portrait' or 'landscape' for every page, or 'auto' to turn a page landscape when its image is wider than tall. Ignored for 'fit'."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "json"
  ],
  "properties": {
    "json": {
      "type": "string",
      "maxLength": 2000000,
      "minLength": 1,
      "description": "The JSON text to work on. Invalid JSON comes back as an error naming where parsing failed."
    },
    "action": {
      "enum": [
        "format",
        "minify",
        "validate"
      ],
      "type": "string",
      "default": "format",
      "description": "'format' pretty-prints with the indent given; 'minify' strips all whitespace into one line; 'validate' only checks that it parses and returns the text unchanged."
    },
    "indent": {
      "anyOf": [
        {
          "type": "integer",
          "maximum": 8,
          "minimum": 0
        },
        {
          "type": "string",
          "const": "tab"
        }
      ],
      "default": 2,
      "description": "Spaces per nesting level when formatting, or 'tab' for one tab per level. 0 gives no indentation. Ignored by minify and validate."
    },
    "sortKeys": {
      "type": "boolean",
      "default": false,
      "description": "Sort object keys alphabetically at every level when formatting, so two documents can be compared. Arrays keep their order. Ignored by minify and validate."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "token"
  ],
  "properties": {
    "token": {
      "type": "string",
      "maxLength": 100000,
      "minLength": 1,
      "description": "The JWT to decode: three base64url parts joined by dots. A leading 'Bearer ' is stripped. The header and payload are decoded and the signature is returned as is; nothing is verified, and the result says so."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "amount",
    "rate",
    "years"
  ],
  "properties": {
    "rate": {
      "type": "number",
      "maximum": 100,
      "minimum": 0,
      "description": "Nominal annual interest rate as a percentage, so 5.5 means 5.5% a year. 0 is a real case: an interest-free loan repaid in equal instalments."
    },
    "years": {
      "type": "number",
      "maximum": 50,
      "description": "Length of the loan in years. Fractions are allowed and rounded to whole months, so 2.5 is 30 monthly payments.",
      "exclusiveMinimum": 0
    },
    "amount": {
      "type": "number",
      "description": "The principal borrowed, in whatever currency you are working in. Every figure in the answer is in the same units.",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "unit": {
      "enum": [
        "paragraphs",
        "sentences",
        "words"
      ],
      "type": "string",
      "default": "paragraphs",
      "description": "What `count` counts. Paragraphs hold three to six sentences each and are separated by a blank line; sentences run on in one block; words come back as a single sentence."
    },
    "count": {
      "type": "integer",
      "default": 3,
      "maximum": 100,
      "minimum": 1,
      "description": "How many of `unit` to generate, up to 100. Three paragraphs when omitted."
    },
    "startWithLorem": {
      "type": "boolean",
      "default": true,
      "description": "Open with the familiar \"Lorem ipsum dolor sit amet, consectetur adipiscing elit\". Off, and every word is drawn at random from the start."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "address"
  ],
  "properties": {
    "address": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1,
      "description": "A MAC address in any common form — 'D8:3A:DD:11:22:33', 'd8-3a-dd-11-22-33', 'D83A.DD11.2233' or 'd83add112233'. An EUI-64 (16 hex digits) works too, and so does a bare 24-, 28- or 36-bit prefix on its own if that is all you have."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 2000000,
      "minLength": 1,
      "description": "The Markdown to convert: CommonMark plus the GitHub extensions (tables, strikethrough, task lists, autolinks). Links are limited to http, https, mailto, tel, ftp and relative URLs; other schemes are dropped."
    },
    "breaks": {
      "type": "boolean",
      "default": false,
      "description": "Turn every single newline into a <br>, the way chat apps do. Off, and only a line ending in two spaces breaks; other newlines join into the same paragraph."
    },
    "allowHtml": {
      "type": "boolean",
      "default": false,
      "description": "Pass any raw HTML in the Markdown through to the output instead of escaping it. Off by default, which is the safe choice: inline HTML can carry a script, so only turn this on for Markdown you wrote yourself."
    },
    "headingIds": {
      "type": "boolean",
      "default": false,
      "description": "Give every heading an id derived from its text, made unique within the document, so a table of contents can link to it. Off, and headings carry no id."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "samples"
  ],
  "properties": {
    "samples": {
      "type": "array",
      "items": {
        "type": "number",
        "maximum": 1,
        "minimum": -1,
        "description": "One mono PCM sample as a float from -1 to 1, where 1 is full scale."
      },
      "maxItems": 200000,
      "minItems": 1,
      "description": "A block of decoded mono audio samples, each between -1 and 1. Loudness (RMS), peak and the verdict are judged over the whole block, so send a stretch of speech rather than a single frame; a peak at or above 0.99 counts as clipping."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 100000,
      "minLength": 1,
      "description": "Plain text to turn into morse, or morse to turn back into text. Morse is dots and dashes with a space between letters and a slash (or two spaces) between words; middle dots and en or em dashes are accepted as well."
    },
    "direction": {
      "enum": [
        "auto",
        "toMorse",
        "toText"
      ],
      "type": "string",
      "default": "auto",
      "description": "Which way to translate. \"auto\" decodes when the input is nothing but dots, dashes, spaces and slashes, and encodes otherwise; \"toMorse\" and \"toText\" force one direction. Anything with no morse equivalent comes back as <x> and is listed in `unsupported`."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "weight",
    "reps"
  ],
  "properties": {
    "reps": {
      "type": "integer",
      "maximum": 20,
      "minimum": 1,
      "description": "How many reps were completed with that weight, 1 to 20. One rep returns the weight itself rather than a formula's estimate of it. Above ten the estimate is reported with `reliable: false`."
    },
    "weight": {
      "type": "number",
      "maximum": 2000,
      "description": "The weight lifted, in kilograms or pounds — the unit is never converted, so every number that comes back is in the same one you sent.",
      "exclusiveMinimum": 0
    },
    "formula": {
      "enum": [
        "epley",
        "brzycki",
        "lombardi",
        "oconner",
        "wathan",
        "lander",
        "mayhew"
      ],
      "type": "string",
      "default": "epley",
      "description": "Which published regression to use for the headline figure. Epley is the usual default and what most lifting apps show; every formula's answer comes back in `estimates` regardless."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "unit": {
      "enum": [
        "km",
        "miles"
      ],
      "type": "string",
      "default": "km",
      "description": "The unit `distance` and `paceSecondsPerUnit` are read in. The answer always reports pace per kilometre and per mile, whichever was given."
    },
    "distance": {
      "type": "number",
      "maximum": 100000,
      "description": "How far, in the unit named by `unit`. Give any two of distance, timeSeconds and paceSecondsPerUnit and the third is worked out.",
      "exclusiveMinimum": 0
    },
    "timeSeconds": {
      "type": "number",
      "maximum": 864000,
      "description": "Total time in seconds, so 3150 is 52 minutes 30 seconds.",
      "exclusiveMinimum": 0
    },
    "paceSecondsPerUnit": {
      "type": "number",
      "maximum": 36000,
      "description": "Pace in seconds per `unit`, so 315 with unit km is 5:15 per kilometre. Ignored when distance and timeSeconds are both given, since those two determine it.",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "count": {
      "type": "integer",
      "default": 1,
      "maximum": 50,
      "minimum": 1,
      "description": "How many passwords to return, up to 50. Always an array."
    },
    "digits": {
      "type": "boolean",
      "default": true,
      "description": "Include 0-9."
    },
    "length": {
      "type": "integer",
      "default": 20,
      "maximum": 128,
      "minimum": 4,
      "description": "Characters per password, 4 to 128. The reported entropy in bits grows with the length and with how many character sets are on."
    },
    "symbols": {
      "type": "boolean",
      "default": true,
      "description": "Include the symbols !#$%&*+-=?@^_~. Turn off for systems that refuse punctuation."
    },
    "lowercase": {
      "type": "boolean",
      "default": true,
      "description": "Include a-z. Every password is guaranteed at least one character from each set that is on, and at least one of the four sets must be on."
    },
    "uppercase": {
      "type": "boolean",
      "default": true,
      "description": "Include A-Z."
    },
    "excludeAmbiguous": {
      "type": "boolean",
      "default": false,
      "description": "Leave out I, l, 1, O, 0 and o, which are misread when a password is written down or read aloud. Slightly lowers the entropy."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 28000000,
      "minLength": 1,
      "description": "The PDF to compress, base64-encoded (a data: URL prefix is stripped). The result comes back the same way in `data`."
    },
    "name": {
      "type": "string",
      "default": "document.pdf",
      "maxLength": 255,
      "description": "Filename echoed back as `name` in the response. Used for nothing else."
    },
    "level": {
      "enum": [
        "light",
        "balanced",
        "strong"
      ],
      "type": "string",
      "default": "balanced",
      "description": "How hard to squeeze the embedded JPEGs. light re-encodes at quality 0.82 with the longest edge capped at 2400 px, balanced 0.65 and 1800 px, strong 0.45 and 1400 px. Text, fonts and vector graphics are untouched at every level."
    },
    "structureOnly": {
      "type": "boolean",
      "default": false,
      "description": "Leave every image as it is and only rewrite the file structure with object streams. Saves a little on text-heavy documents and almost nothing on scans."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "files"
  ],
  "properties": {
    "files": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "data"
        ],
        "properties": {
          "data": {
            "type": "string",
            "maxLength": 28000000,
            "minLength": 1,
            "description": "This PDF's bytes, base64-encoded. A data: URL prefix is stripped."
          },
          "name": {
            "type": "string",
            "default": "document.pdf",
            "maxLength": 255,
            "description": "Filename used to identify this PDF in the response's `sources` list and in any error message about it."
          }
        },
        "description": "One PDF to include, with all of its pages."
      },
      "maxItems": 30,
      "minItems": 2,
      "description": "The PDFs to join, in the order their pages should appear in the result. Needs at least two, and no more than 30 in one request."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 70000000,
      "minLength": 1,
      "description": "The PDF to rebuild, base64-encoded. A data: URL prefix is stripped."
    },
    "name": {
      "type": "string",
      "default": "document",
      "maxLength": 255,
      "description": "Base name for the output file; a .pdf ending is dropped and the response names it <name>.pdf."
    },
    "order": {
      "type": "string",
      "maxLength": 2000,
      "description": "Source page numbers, 1-based, in the order they should appear, as \"3, 1, 2\". A range may run backwards, so \"10-1\" reverses a ten-page document. Leave a page out to delete it and repeat one to duplicate it. Omit to keep every page in its current order."
    },
    "rotations": {
      "type": "object",
      "description": "Extra clockwise rotation per source page, as {\"2\": 90}. Added to whatever rotation the page already has, and keyed by source page rather than output position, so it holds good after a reorder.",
      "propertyNames": {
        "type": "string",
        "description": "A source page number, 1-based, as a string key."
      },
      "additionalProperties": {
        "anyOf": [
          {
            "type": "number",
            "const": 0
          },
          {
            "type": "number",
            "const": 90
          },
          {
            "type": "number",
            "const": 180
          },
          {
            "type": "number",
            "const": 270
          }
        ],
        "description": "Clockwise degrees to add to that page."
      }
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 28000000,
      "minLength": 1,
      "description": "The PDF to rotate, base64-encoded. A data: URL prefix is stripped."
    },
    "name": {
      "type": "string",
      "default": "document",
      "maxLength": 255,
      "description": "Base name for the output file; a .pdf ending is dropped and the response names it <name>-rotated.pdf."
    },
    "only": {
      "enum": [
        "all",
        "landscape",
        "portrait"
      ],
      "type": "string",
      "default": "all",
      "description": "Filter the selected pages by their current orientation: landscape turns only pages wider than tall, portrait only pages taller than wide, all turns every selected page. The response lists which pages actually turned."
    },
    "angle": {
      "anyOf": [
        {
          "type": "number",
          "const": 90
        },
        {
          "type": "number",
          "const": 180
        },
        {
          "type": "number",
          "const": 270
        }
      ],
      "default": 90,
      "description": "Clockwise rotation in degrees, added to whatever rotation each page already has. Lossless: nothing is re-rendered. A quarter turn when omitted."
    },
    "pages": {
      "type": "string",
      "maxLength": 500,
      "description": "Which pages to rotate, counted from 1: single pages and ranges separated by commas, such as \"1-3, 7, 12-\", where an open end runs to the last page. Omit for every page."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 28000000,
      "minLength": 1,
      "description": "The PDF to split, base64-encoded. A data: URL prefix is stripped."
    },
    "mode": {
      "enum": [
        "extract",
        "single"
      ],
      "type": "string",
      "default": "extract",
      "description": "extract returns one PDF holding the selected pages; single returns one PDF per selected page. `files` in the response is an array either way."
    },
    "name": {
      "type": "string",
      "default": "document",
      "maxLength": 255,
      "description": "Base name for the output files; a .pdf ending is dropped. extract mode names the result <name>-extracted.pdf, single mode <name>-page-N.pdf per page."
    },
    "pages": {
      "type": "string",
      "maxLength": 500,
      "description": "Which pages to take, counted from 1: single pages and ranges separated by commas, such as \"1-3, 7, 12-\", where an open end runs to the last page. The order given is kept, so \"3, 1\" puts page 3 first. Omit for every page."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "minLength": 1,
      "description": "The PDF to read, base64-encoded (a data: URL prefix is accepted). It needs a text layer: a scan with no text is refused with `no_text` rather than returning an empty workbook. Refused above 25 MB decoded."
    },
    "joinPages": {
      "type": "boolean",
      "default": true,
      "description": "Treat a table that carries on over a page break as one table, dropping the repeated heading row. On by default, because a statement split across twelve pages is one table; turn it off to get one sheet per page."
    },
    "sheetName": {
      "type": "string",
      "default": "Table",
      "maxLength": 24,
      "minLength": 1,
      "description": "What to call a tab the document did not name — `Table` gives Table 1, Table 2. A table the document headed keeps its own heading instead, trimmed to what Excel allows and made unique if it has to be."
    },
    "includeText": {
      "type": "boolean",
      "default": true,
      "description": "Also keep everything that was not in a table — headings and paragraphs, in reading order, with the page each came from — as a sheet of its own. On by default: on an invoice the total being charged is a line of prose above the tables rather than a row inside one, so a workbook of only the grids has lost the number the document is about."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "minLength": 1,
      "description": "The PDF to convert, base64-encoded (a data: URL prefix is accepted). It needs a text layer: a scan with no text is refused with `no_text` rather than turned into an empty document. Refused above 25 MB decoded."
    },
    "keepPageBreaks": {
      "type": "boolean",
      "default": false,
      "description": "Start a new page in the Word document wherever the PDF started one. Off by default, so the text reflows and the Word page count may differ from the PDF's."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "mode",
    "a",
    "b"
  ],
  "properties": {
    "a": {
      "type": "number",
      "description": "The first number, as a plain number with no % sign: the percentage in of, the part in what, the starting value in change and adjust."
    },
    "b": {
      "type": "number",
      "description": "The second number, as a plain number: the whole in of and what, the end value in change, the percentage to change by in adjust."
    },
    "mode": {
      "enum": [
        "of",
        "what",
        "change",
        "adjust"
      ],
      "type": "string",
      "description": "Which sum to do. of: a percent of b (15, 80 gives 12). what: a as a percentage of b (12, 80 gives 15). change: the percentage change from a to b, measured against a (80, 92 gives up 15). adjust: a changed by b percent (80, 15 gives 92; a negative b is a discount)."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "lmpDate"
  ],
  "properties": {
    "lmpDate": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "First day of the last menstrual period as YYYY-MM-DD. Everything is counted from this date by Naegele's rule (280 days to the due date), shifted by `cycleLength`. Refused if it is in the future or more than 48 weeks ago."
    },
    "asOfDate": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "The date to measure weeks, days and trimester to, as YYYY-MM-DD. Omit and the server uses today's date in UTC, which can be a day out near midnight; send the reader's own local date when you have it."
    },
    "cycleLength": {
      "type": "integer",
      "default": 28,
      "maximum": 45,
      "minimum": 20,
      "description": "Average menstrual cycle length in days. 28 is what Naegele's rule assumes; each day longer moves the due date and the estimated conception date one day later."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "maxLength": 35000000,
      "minLength": 1,
      "description": "The .pub file's bytes, base64-encoded. Publisher files are OLE2 compound documents; a .docx or .pdf sent here is refused rather than guessed at."
    },
    "name": {
      "type": "string",
      "default": "publication.pub",
      "maxLength": 255,
      "description": "What to call the result. The extension is replaced with .pdf."
    },
    "page": {
      "enum": [
        "same",
        "a4",
        "letter"
      ],
      "type": "string",
      "default": "same",
      "description": "Paper for the result. 'a4' and 'letter' re-flow the words onto a sheet of that size. 'same' asks to keep the document's own page size and layout — which this endpoint cannot do yet, so it answers with the A4 re-flow and says so in 'layoutUnavailable'. The page itself is kept in the browser, at helpyself.com/pub-to-pdf/."
    },
    "pictures": {
      "type": "boolean",
      "default": true,
      "description": "Keep the pictures the file carries — photographs, and the clip art Publisher stores as drawings, which are redrawn. Off returns the words only, which is what somebody pasting a parish magazine into an email wants."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "dark": {
      "type": "string",
      "default": "#000000",
      "pattern": "^#[0-9a-f]{6}$",
      "description": "Colour of the modules as a six-digit hex code, such as #000000."
    },
    "size": {
      "type": "integer",
      "default": 512,
      "maximum": 2048,
      "minimum": 64,
      "description": "Declared width and height of the SVG in pixels. The output is vector, so it scales cleanly; this mainly matters when the SVG is rasterised as-is."
    },
    "text": {
      "type": "string",
      "maxLength": 2000,
      "minLength": 1,
      "description": "What the code should contain: a URL, plain text or any other string. Surrounding whitespace is trimmed. QR codes hold about 2,000 characters at most, and the denser the content the harder the code is to scan."
    },
    "light": {
      "type": "string",
      "default": "#ffffff",
      "pattern": "^#[0-9a-f]{6}$",
      "description": "Background colour as a six-digit hex code. Keep it much lighter than `dark`; scanners expect dark modules on a light ground."
    },
    "margin": {
      "type": "integer",
      "default": 4,
      "maximum": 16,
      "minimum": 0,
      "description": "Quiet zone around the code, in modules (the small squares), not pixels. The QR spec recommends 4; less and some scanners fail to lock on."
    },
    "errorCorrection": {
      "enum": [
        "L",
        "M",
        "Q",
        "H"
      ],
      "type": "string",
      "default": "M",
      "description": "How much of the code may be damaged or covered and still scan: L about 7%, M 15%, Q 25%, H 30%. Higher levels make a denser code for the same text."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "max": {
      "type": "integer",
      "default": 100,
      "maximum": 1000000000,
      "minimum": -1000000000,
      "description": "Highest whole number that may be drawn, inclusive. Must not be below `min`. 100 when omitted."
    },
    "min": {
      "type": "integer",
      "default": 1,
      "maximum": 1000000000,
      "minimum": -1000000000,
      "description": "Lowest whole number that may be drawn, inclusive. 1 when omitted."
    },
    "count": {
      "type": "integer",
      "default": 1,
      "maximum": 1000,
      "minimum": 1,
      "description": "How many numbers to draw, up to 1000. Always returned as an array."
    },
    "sorted": {
      "type": "boolean",
      "default": false,
      "description": "Return the draw in ascending order. Sorting happens after drawing, so it does not change the odds."
    },
    "unique": {
      "type": "boolean",
      "default": false,
      "description": "Draw without repeats, like lottery balls rather than dice. Refused if `count` is more than the range holds."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "items"
  ],
  "properties": {
    "count": {
      "type": "integer",
      "default": 1,
      "maximum": 9007199254740991,
      "minimum": 1,
      "description": "How many entries to pick, without repeats. Asking for more than the list holds is an error rather than a shorter answer. Ignored when shuffleAll is true."
    },
    "items": {
      "type": "array",
      "items": {
        "type": "string",
        "description": "One entry to draw from. Duplicates are kept and weight the draw."
      },
      "maxItems": 10000,
      "minItems": 1,
      "description": "The list to pick from, up to 10000 entries. An entry written twice is deliberately twice as likely to be picked, so duplicates are not collapsed."
    },
    "shuffleAll": {
      "type": "boolean",
      "default": false,
      "description": "Return the whole list in a random order instead of a selection. Every ordering is equally likely, and count is ignored."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "names"
  ],
  "properties": {
    "mode": {
      "enum": [
        "teams",
        "size"
      ],
      "type": "string",
      "default": "teams",
      "description": "What count means. \"teams\": make that many teams. \"size\": make teams of that many people, with the last team taking the remainder rather than anyone being left out."
    },
    "count": {
      "type": "integer",
      "default": 2,
      "maximum": 1000,
      "minimum": 1,
      "description": "The number of teams, or the people per team, depending on mode. Names are dealt round-robin after a shuffle, so team sizes never differ by more than one."
    },
    "names": {
      "type": "string",
      "maxLength": 100000,
      "minLength": 1,
      "description": "The people to deal out, one name per line. Lines are trimmed and blank lines are dropped, so a pasted spreadsheet column works as it is."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "left",
    "right"
  ],
  "properties": {
    "left": {
      "type": "number",
      "description": "The left side of the ratio, the a in a:b. Decimals are allowed and are scaled to whole numbers before reducing, so 2.5:1 simplifies to 5:2 rather than rounding to 3:1.",
      "exclusiveMinimum": 0
    },
    "right": {
      "type": "number",
      "description": "The right side of the ratio, the b in a:b. A zero side is refused as not a ratio.",
      "exclusiveMinimum": 0
    },
    "scaleTo": {
      "type": "number",
      "minimum": 0,
      "description": "A new left-hand value to solve for: given, the answer is the c in a:b = scaleTo:c, returned as solved.value with a whole flag, since 16:9 at 1000 wide is 562.5 and is not rounded. Omitted, the ratio is only simplified."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 200000,
      "minLength": 1,
      "description": "English prose to score, at least 20 words. Scored with Flesch Reading Ease, Flesch-Kincaid, Gunning fog, SMOG, ARI and Coleman-Liau, which are averages over sentence and syllable counts, so a short passage gives a rough answer."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "pattern"
  ],
  "properties": {
    "pattern": {
      "type": "string",
      "maxLength": 10000,
      "minLength": 1,
      "description": "A JavaScript regular expression to explain, either bare or as /pattern/flags. It is read, never run, so a pattern that would not compile is still explained, with the problems listed alongside."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "pattern",
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 20000,
      "description": "The text to run the pattern against, at most 20000 characters. Matches are returned with their index and capture groups, and stop after 1000."
    },
    "flags": {
      "type": "string",
      "default": "g",
      "pattern": "^[dgimsuvy]*$",
      "maxLength": 8,
      "description": "The standard JavaScript flags as one string, such as \"gi\". The default \"g\" returns every match; without it only the first match is returned."
    },
    "pattern": {
      "type": "string",
      "maxLength": 500,
      "minLength": 1,
      "description": "A JavaScript regular expression, bare, without surrounding slashes; flags go in flags. At most 500 characters, which is shorter than the page allows."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "mode": {
      "enum": [
        "paragraphs",
        "all"
      ],
      "type": "string",
      "default": "paragraphs",
      "description": "What to keep. \"paragraphs\" removes the breaks inside a paragraph and keeps the blank line between paragraphs, which is almost always what is wanted; \"all\" collapses everything to a single line."
    },
    "text": {
      "type": "string",
      "maxLength": 1000000,
      "minLength": 1,
      "description": "The hard-wrapped text to reflow — copied out of a P D F, an email or a terminal."
    },
    "joinWith": {
      "enum": [
        "space",
        "nothing"
      ],
      "type": "string",
      "default": "space",
      "description": "What replaces a removed break. \"nothing\" is for scripts written without spaces between words, where a space would be wrong."
    },
    "keepLists": {
      "type": "boolean",
      "default": true,
      "description": "Leave a line that starts a list item on its own line. A hard-wrapped document is full of them, and joining a bulleted list into a sentence loses the only structure it had."
    },
    "mendHyphens": {
      "type": "boolean",
      "default": true,
      "description": "Rejoin a word the line break split: \"inter-\" then \"national\" becomes \"international\". Only applied where the next line starts lower-case, so a real hyphen in \"well-Known\" is left alone."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "days": {
      "type": "integer",
      "default": 7,
      "maximum": 30,
      "minimum": 1,
      "description": "How many days a request link would stay open for uploads, at most 30; there is no permanent option. This call only describes such a link and creates nothing; creating one is a separate, signed-in POST to the createAt path returned."
    },
    "maxFiles": {
      "type": "integer",
      "default": 10,
      "maximum": 100,
      "minimum": 1,
      "description": "How many files the link would accept before closing itself, at most 100. Each file is also capped at what the owner's own plan allows and counts against their storage."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "numeral"
  ],
  "properties": {
    "numeral": {
      "type": "string",
      "maxLength": 40,
      "minLength": 1,
      "description": "Either a Roman numeral (\"MCMXCIV\") or a whole number from 1 to 3999 (\"1994\"); the direction is worked out from what is given. Loose forms like IIII are read and reported with strict false, and the strict modern spelling is returned alongside."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "amount",
    "period"
  ],
  "properties": {
    "amount": {
      "type": "number",
      "minimum": 0,
      "description": "The gross pay figure you already know, in any currency; no tax or deductions are applied. It is converted to all five periods using the working pattern below."
    },
    "period": {
      "enum": [
        "hour",
        "day",
        "week",
        "month",
        "year"
      ],
      "type": "string",
      "description": "Which period amount covers. A month is always a twelfth of a year, never 4.33 weeks."
    },
    "daysPerWeek": {
      "type": "number",
      "default": 5,
      "maximum": 7,
      "description": "Days worked in a normal week, used for the daily figure. Defaults to 5.",
      "exclusiveMinimum": 0
    },
    "hoursPerWeek": {
      "type": "number",
      "default": 37.5,
      "maximum": 168,
      "description": "Hours worked in a normal week, used to turn an hourly rate into a weekly one and back. Defaults to 37.5; 40 is usual in the US.",
      "exclusiveMinimum": 0
    },
    "weeksPerYear": {
      "type": "number",
      "default": 52,
      "maximum": 53,
      "description": "Weeks paid in a year, used to turn a weekly figure into an annual one and back. Defaults to 52; use 52.18 to count the odd days.",
      "exclusiveMinimum": 0
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data",
    "iv"
  ],
  "properties": {
    "iv": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1,
      "description": "The base64-encoded AES-GCM initialisation vector used to encrypt data. Not secret; it is stored beside the ciphertext so the recipient can decrypt."
    },
    "data": {
      "type": "string",
      "maxLength": 20000,
      "minLength": 1,
      "description": "The secret as base64-encoded AES-GCM ciphertext, encrypted by the caller before sending. Never plaintext: the server stores this without being able to read it, and the decryption key must be appended by the caller to the returned URL after the #, where a browser never sends it. Sized for a password, not a document."
    },
    "salt": {
      "type": "string",
      "maxLength": 64,
      "description": "The base64-encoded salt the password-derived key was made with. Give it only when the secret is additionally locked with a password; omit it otherwise."
    },
    "keyProof": {
      "type": "string",
      "maxLength": 64,
      "description": "Base64-encoded SHA-256 digest of the password-derived key, letting the server check a password attempt without ever holding the password or the key. Omit it when there is no password."
    },
    "lifetime": {
      "enum": [
        "1h",
        "24h",
        "7d"
      ],
      "type": "string",
      "default": "24h",
      "description": "How long the stored ciphertext lives if nobody opens it: 1h, 24h, 7d. It is also destroyed on first read, and there is no permanent option. Each call stores a new secret and returns a new link, so call once per secret."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "time"
  ],
  "properties": {
    "time": {
      "type": "string",
      "maxLength": 5,
      "minLength": 3,
      "description": "A 24-hour clock reading with a colon, such as \"07:30\" or \"23:15\". No date or time zone is involved. \"7.30\" or \"7:30 pm\" is refused."
    },
    "timeIs": {
      "enum": [
        "wake",
        "bedtime"
      ],
      "type": "string",
      "default": "wake",
      "description": "What time is: \"wake\" means it is the alarm and bedtimes are returned, most sleep first; \"bedtime\" means it is when you go to bed and wake times are returned, earliest first. 4 options come back, for 3 to 6 cycles."
    },
    "cycleMinutes": {
      "type": "integer",
      "default": 90,
      "maximum": 180,
      "minimum": 30,
      "description": "Length of one sleep cycle in minutes. 90 is the adult average; real cycles run roughly 70 to 120 and differ between people."
    },
    "fallAsleepMinutes": {
      "type": "integer",
      "default": 15,
      "maximum": 120,
      "minimum": 0,
      "description": "Minutes spent falling asleep after going to bed, subtracted from a bedtime or added to a wake time. Defaults to 15."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 10000,
      "minLength": 1,
      "description": "The title or phrase to turn into a URL slug. Accents are stripped, & becomes \"and\", apostrophes are dropped, and every other non-alphanumeric run becomes one separator."
    },
    "lowercase": {
      "type": "boolean",
      "default": true,
      "description": "Lower-case the result. False keeps the capitals of the input."
    },
    "maxLength": {
      "type": "integer",
      "default": 0,
      "maximum": 200,
      "minimum": 0,
      "description": "Longest slug allowed, in characters; 0 means no limit. A slug is cut at the last separator inside the limit, so a word is never cut in half."
    },
    "separator": {
      "enum": [
        "-",
        "_"
      ],
      "type": "string",
      "default": "-",
      "description": "The character put between words. Hyphens are what search engines expect."
    },
    "expandDiacritics": {
      "type": "boolean",
      "default": true,
      "description": "Write letters that romanise as two characters that way: ø to oe, æ to ae, å to aa, ü to ue, ß to ss. False uses the nearest single letter instead: ø to o, ß to s."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "sql"
  ],
  "properties": {
    "sql": {
      "type": "string",
      "maxLength": 500000,
      "minLength": 1,
      "description": "The SQL to lay out, one or more statements, at most 500000 characters. It is only reformatted: nothing checks that it would run."
    },
    "indent": {
      "enum": [
        "2",
        "4",
        "tab"
      ],
      "type": "string",
      "default": "2",
      "description": "What one level of indentation is: \"2\" or \"4\" spaces, or \"tab\"."
    },
    "dialect": {
      "enum": [
        "sql",
        "postgresql",
        "mysql",
        "mariadb",
        "sqlite",
        "transactsql",
        "plsql",
        "bigquery",
        "snowflake",
        "redshift",
        "spark",
        "db2",
        "hive",
        "trino",
        "clickhouse",
        "duckdb"
      ],
      "type": "string",
      "default": "sql",
      "description": "Which database's syntax to parse it as, one of 16 dialects. \"sql\" is generic standard SQL and is what to use when unsure; \"transactsql\" is SQL Server and \"plsql\" is Oracle."
    },
    "keywordCase": {
      "enum": [
        "upper",
        "lower",
        "preserve"
      ],
      "type": "string",
      "default": "upper",
      "description": "How keywords are written: \"upper\" gives SELECT, \"lower\" gives select, \"preserve\" leaves each keyword as it was typed."
    },
    "linesBetweenQueries": {
      "type": "integer",
      "default": 1,
      "maximum": 5,
      "minimum": 0,
      "description": "How many blank lines to leave between statements."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "network"
  ],
  "properties": {
    "network": {
      "type": "string",
      "maxLength": 40,
      "minLength": 7,
      "description": "An IPv4 address with a prefix length (\"192.168.1.10/24\"), an address and a dotted mask separated by a space (\"10.0.0.1 255.0.0.0\"), or a bare address, which is read as /24. Octets with leading zeros are refused, as is a mask that is not a run of ones followed by zeros."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "original",
    "changed"
  ],
  "properties": {
    "changed": {
      "type": "string",
      "maxLength": 500000,
      "description": "The later version, compared against original. Lines only in it are reported as insertions; lines only in original as deletions."
    },
    "original": {
      "type": "string",
      "maxLength": 500000,
      "description": "The earlier version of the text. Compared line by line, split on newlines."
    },
    "ignoreCase": {
      "type": "boolean",
      "default": false,
      "description": "Treat lines that differ only in letter case as equal. The reported lines keep their original case."
    },
    "ignoreWhitespace": {
      "type": "boolean",
      "default": false,
      "description": "Treat lines as equal when they differ only in leading, trailing or repeated whitespace, so an indentation change no longer counts as a change."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "shifts"
  ],
  "properties": {
    "rate": {
      "type": "number",
      "minimum": 0,
      "description": "Pay per hour. Omit it and the result gives hours only, with pay as null."
    },
    "shifts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "start",
          "end"
        ],
        "properties": {
          "end": {
            "type": "string",
            "maxLength": 10,
            "minLength": 1,
            "description": "Clock-out time, in the same forms as start. Earlier than start means the shift ran past midnight; 24:00 is accepted as the end of the day."
          },
          "label": {
            "type": "string",
            "maxLength": 40,
            "description": "A free-form name for the shift, such as a weekday or a date. Returned unchanged on the matching day in the result."
          },
          "start": {
            "type": "string",
            "maxLength": 10,
            "minLength": 1,
            "description": "Clock-in time. Forgiving: \"9:00\", \"9.00\", \"0900\", \"9am\" and \"9\" all read the same."
          },
          "breakMinutes": {
            "type": "number",
            "maximum": 1440,
            "minimum": 0,
            "description": "Unpaid break in minutes, taken off the shift. Must be shorter than the shift itself. Defaults to 0."
          }
        }
      },
      "maxItems": 31,
      "minItems": 1,
      "description": "The shifts to total, one entry each. A shift ending before it starts is read as crossing midnight, never as negative."
    },
    "overtimeAfter": {
      "type": "number",
      "maximum": 168,
      "minimum": 0,
      "description": "Weekly hours after which the remaining hours count as overtime. Omitted means no overtime is worked out."
    },
    "overtimeMultiplier": {
      "type": "number",
      "maximum": 10,
      "minimum": 1,
      "description": "What overtime hours are paid at, as a multiple of rate: 1.5 is the usual. Only matters when overtimeAfter and rate are set; defaults to 1."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "maxLength": 200,
      "minLength": 1,
      "description": "A Unix timestamp or a date. A bare number is read as seconds, or as milliseconds once it reaches 100000000000 (1e11); negative means before 1970. Anything else is parsed as a date string such as 2026-08-03T12:00:00Z."
    },
    "timeZone": {
      "type": "string",
      "maxLength": 64,
      "description": "IANA zone name, e.g. \"Europe/Copenhagen\", used for the local reading and the day of the week. Defaults to UTC, and an unknown name falls back to UTC rather than failing."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "date",
    "time",
    "fromZone",
    "toZones"
  ],
  "properties": {
    "date": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "The calendar date on the wall clock in fromZone, as YYYY-MM-DD."
    },
    "time": {
      "type": "string",
      "pattern": "^\\d{2}:\\d{2}$",
      "description": "The wall-clock time in fromZone, 24-hour, as HH:MM. A time the clocks skip is moved forward and flagged; one that happens twice is read as the first."
    },
    "toZones": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 80,
        "minLength": 1,
        "description": "An IANA zone name such as \"Asia/Tokyo\"."
      },
      "maxItems": 50,
      "minItems": 1,
      "description": "IANA zone names to read the same moment in. Each comes back with its own date, time, abbreviation, UTC offset and whether it is a day ahead or behind."
    },
    "fromZone": {
      "type": "string",
      "maxLength": 80,
      "minLength": 1,
      "description": "IANA zone name the date and time are read in, e.g. \"America/New_York\". Abbreviations such as EST or CST are not accepted, since they are ambiguous."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "bill",
    "tipPercent",
    "people"
  ],
  "properties": {
    "bill": {
      "type": "number",
      "description": "The amount on the bill before any tip, in whatever currency you use. Tax it already contains is handled by taxRate.",
      "exclusiveMinimum": 0
    },
    "people": {
      "type": "integer",
      "maximum": 1000,
      "minimum": 1,
      "description": "How many ways to split the total. 1 means no split."
    },
    "roundTo": {
      "type": "number",
      "maximum": 1000,
      "minimum": 0,
      "description": "Round each person's share up to this step in the bill's currency: 1 for whole units, 0.5 for halves. 0 or omitted keeps the exact share. Always up, never down."
    },
    "taxRate": {
      "type": "number",
      "maximum": 100,
      "minimum": 0,
      "description": "Sales tax already included in bill, as a percentage. It is taken off before the tip is worked out, so the tip is on the pre-tax amount. 0 or omitted tips on the whole bill, which is the norm outside the US."
    },
    "tipPercent": {
      "type": "number",
      "maximum": 1000,
      "minimum": 0,
      "description": "The tip as a percentage of the bill, or of the pre-tax amount when taxRate is set: 15 means 15%."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "target",
    "typed",
    "elapsedMs"
  ],
  "properties": {
    "typed": {
      "type": "string",
      "maxLength": 20000,
      "description": "What was actually typed, exactly as entered. Shorter than target is fine; the untyped rest counts as pending."
    },
    "target": {
      "type": "string",
      "maxLength": 20000,
      "minLength": 1,
      "description": "The passage the person was supposed to type. Compared against typed character by character, position by position."
    },
    "elapsedMs": {
      "type": "integer",
      "maximum": 3600000,
      "minimum": 0,
      "description": "Time taken, in milliseconds. Words per minute counts five characters as a word; 0 scores 0 wpm rather than dividing by zero."
    },
    "includeCharacters": {
      "type": "boolean",
      "default": false,
      "description": "Also return a verdict for every character of target: correct, incorrect or pending. Off by default because it is thousands of strings for a minute of typing."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "type": "string",
      "maxLength": 10,
      "minLength": 1,
      "description": "Unit id to convert to, from the same category and the same list of ids as from."
    },
    "from": {
      "type": "string",
      "maxLength": 10,
      "minLength": 1,
      "description": "Unit id to convert from, which must belong to category. Ids by category: length: mm, cm, m, km, in, ft, yd, mi; mass: g, kg, t, oz, lb, st; temperature: c, f, k; volume: ml, l, tsp, tbsp, cup, pt, gal, galuk; area: cm2, m2, km2, ft2, yd2, acre, ha; speed: kmh, mph, ms, kn; data: b, kb, mb, gb, tb, kib, mib, gib, tib; time: ms, s, min, h, d, wk."
    },
    "value": {
      "type": "number",
      "default": 1,
      "description": "The quantity to convert, expressed in the from unit. Defaults to 1."
    },
    "category": {
      "enum": [
        "length",
        "mass",
        "temperature",
        "volume",
        "area",
        "speed",
        "data",
        "time"
      ],
      "type": "string",
      "default": "length",
      "description": "Which kind of quantity: length, mass, temperature, volume, area, speed, data, time. Both from and to must be units of this category. Defaults to length."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 10000,
      "minLength": 1,
      "description": "The text to turn upside down, or upside-down text to turn back the right way up."
    },
    "direction": {
      "enum": [
        "auto",
        "flip",
        "unflip"
      ],
      "type": "string",
      "default": "auto",
      "description": "Which way to translate. \"auto\" turns upside-down text back the right way up and flips anything else; \"flip\" and \"unflip\" force one direction."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "mode": {
      "enum": [
        "component",
        "full"
      ],
      "type": "string",
      "default": "component",
      "description": "component encodes or decodes every reserved character, as encodeURIComponent does, which is right for one query value. full leaves the characters that structure a URL (/ ? & = : #) alone, as encodeURI does, which is right for a whole address. Ignored by parse."
    },
    "text": {
      "type": "string",
      "maxLength": 100000,
      "minLength": 1,
      "description": "The text to encode, the percent-encoded string to decode, or the URL to parse, depending on action."
    },
    "action": {
      "enum": [
        "encode",
        "decode",
        "parse"
      ],
      "type": "string",
      "default": "encode",
      "description": "encode percent-encodes text; decode reverses it; parse splits a complete URL (scheme included) into protocol, host, path, query parameters and hash, and ignores mode."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "count": {
      "type": "integer",
      "default": 1,
      "maximum": 500,
      "minimum": 1,
      "description": "How many UUIDs to return, 1 to 500. They come back as an array either way."
    },
    "uppercase": {
      "type": "boolean",
      "default": false,
      "description": "Return the hex digits in upper case. The hyphens are unaffected."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "amount",
    "rate",
    "direction"
  ],
  "properties": {
    "rate": {
      "type": "number",
      "maximum": 99.99,
      "minimum": 0,
      "description": "The VAT rate as a percentage: 25 means 25%. Must be below 100."
    },
    "amount": {
      "type": "number",
      "description": "The price. The net (pre-VAT) price when direction is add; the gross (VAT-inclusive) price when it is remove."
    },
    "direction": {
      "enum": [
        "add",
        "remove"
      ],
      "type": "string",
      "description": "add works out the VAT on a net amount and the gross that results. remove takes a gross amount and divides the VAT back out to find the net and the VAT it contained."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data"
  ],
  "properties": {
    "fps": {
      "type": "number",
      "default": 10,
      "maximum": 30,
      "minimum": 1,
      "description": "Frames per second of the GIF. fps times seconds is the frame count, capped at 300. Above about 15 the file grows faster than it improves. Defaults to 10."
    },
    "data": {
      "type": "string",
      "maxLength": 35000000,
      "minLength": 1,
      "description": "The video file, base64-encoded; a data: URL prefix is stripped if present. MP4 is what the transformer expects. Roughly 26 MB of video at most."
    },
    "width": {
      "type": "integer",
      "default": 480,
      "maximum": 1280,
      "minimum": 16,
      "description": "Longest edge of the output in pixels, up to 1280; the other edge follows the clip's aspect ratio. Defaults to 480."
    },
    "seconds": {
      "type": "number",
      "default": 3,
      "maximum": 30,
      "minimum": 0.1,
      "description": "How many seconds of the clip to use, counted from the start. The rest is discarded. Defaults to 3."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {},
  "description": "Takes no arguments. The answer is about whoever makes the call: their public IP address and what can be read from it.",
  "additionalProperties": false
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "names"
  ],
  "properties": {
    "draws": {
      "type": "integer",
      "default": 1,
      "maximum": 100,
      "minimum": 1,
      "description": "How many winners to draw. Without removeWinner each draw is from the full list, so the same name can win more than once. Defaults to 1."
    },
    "names": {
      "type": "string",
      "maxLength": 20000,
      "minLength": 1,
      "description": "The entries to draw from, one per line. Blank lines and surrounding spaces are ignored; a name listed twice has two chances."
    },
    "removeWinner": {
      "type": "boolean",
      "default": false,
      "description": "Take each winner out of the list before the next draw, so no name wins twice. Drawing stops early if the list runs out; remaining in the response lists who is left."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 1000000,
      "description": "The text to count. Returns characters with and without spaces, words, sentences, paragraphs (split on blank lines), lines, reading and speaking time in minutes, and the most frequent words with common ones left out."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "data"
  ],
  "properties": {
    "data": {
      "type": "string",
      "minLength": 1,
      "description": "The Word document, base64-encoded; a data: URL prefix is stripped if present. A .docx is expected, and the older binary .doc is recognised from its bytes too. Up to 25 MB once decoded."
    },
    "pageSize": {
      "enum": [
        "document",
        "a4",
        "letter"
      ],
      "type": "string",
      "default": "document",
      "description": "document keeps the paper size and margins the file was written for. a4 or letter overrides them with that paper and fixed margins, which re-wraps every paragraph. Defaults to document."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "xml"
  ],
  "properties": {
    "xml": {
      "type": "string",
      "maxLength": 1000000,
      "minLength": 1,
      "description": "The XML document to work on."
    },
    "mode": {
      "enum": [
        "format",
        "minify",
        "validate"
      ],
      "type": "string",
      "default": "format",
      "description": "format re-indents it, one node per line; minify puts it on one line; validate only reports whether the tags nest and close, with the line of the first fault. None of them checks against a schema. Defaults to format."
    },
    "indent": {
      "anyOf": [
        {
          "type": "integer",
          "maximum": 8,
          "minimum": 0
        },
        {
          "type": "string",
          "const": "tab"
        }
      ],
      "default": 2,
      "description": "Spaces per nesting level when formatting, or \"tab\" for one tab per level. Ignored by minify and validate. Defaults to 2."
    },
    "keepComments": {
      "type": "boolean",
      "default": true,
      "description": "Keep <!-- --> comments when formatting; false drops them. Defaults to true."
    }
  }
}

{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 2000000,
      "minLength": 1,
      "description": "The document to convert: YAML when direction is yaml-to-json, JSON when it is json-to-yaml. A YAML file holding several --- documents becomes a JSON array."
    },
    "indent": {
      "type": "integer",
      "default": 2,
      "maximum": 8,
      "minimum": 0,
      "description": "Spaces of indentation in the output. For JSON, 0 gives a single line; YAML output always indents by at least 1. Defaults to 2."
    },
    "sortKeys": {
      "type": "boolean",
      "default": false,
      "description": "Sort object keys alphabetically at every level, so two configs can be compared. Off by default, which keeps the input's order."
    },
    "direction": {
      "enum": [
        "yaml-to-json",
        "json-to-yaml"
      ],
      "type": "string",
      "default": "yaml-to-json",
      "description": "yaml-to-json parses YAML and returns JSON; json-to-yaml parses JSON and returns YAML. Defaults to yaml-to-json."
    }
  }
}