Developer Tools

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "to-codes: the text to convert from-codes: the character codes to convert"
    },
    "options": {
      "type": "object",
      "properties": {
        "base": {
          "enum": [
            "dec",
            "hex",
            "bin",
            "oct"
          ],
          "type": "string",
          "description": "Numeric base. Used by: to-codes, from-codes."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "to-codes",
        "from-codes"
      ],
      "type": "string",
      "description": "to-codes — Convert text to character codes. from-codes — Convert character codes back to text."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "analyze: A ratio (16:9, 4/3, 1.85:1) or a size (1920x1080). solve: A ratio or size, e.g. \"16:9\". fit: A ratio or size, e.g. \"9:16\"."
    },
    "options": {
      "type": "object",
      "properties": {
        "mode": {
          "enum": [
            "contain",
            "cover"
          ],
          "type": "string",
          "default": "contain",
          "description": "Like CSS object-fit. Used by: fit."
        },
        "width": {
          "type": "number",
          "description": "Known width (give width or height). Used by: solve."
        },
        "height": {
          "type": "number",
          "description": "Known height. Used by: solve."
        },
        "boxWidth": {
          "type": "number",
          "description": "Box width. Used by: fit. Required by: fit."
        },
        "boxHeight": {
          "type": "number",
          "description": "Box height. Used by: fit. Required by: fit."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "analyze",
        "solve",
        "fit"
      ],
      "type": "string",
      "description": "analyze — Reduce a ratio or size (16:9, 1920x1080, 2.39) and return presets, CSS and whole-pixel sizes. solve — Given a ratio and one dimension, compute the other. fit — Largest size at this ratio that fits inside (contain) or covers (cover) a box."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 4096,
      "description": "encode: The text to encode. decode: The encoded string. Whitespace is ignored."
    },
    "options": {
      "type": "object",
      "properties": {
        "scheme": {
          "enum": [
            "base32",
            "base32hex",
            "crockford",
            "base58",
            "ascii85",
            "z85"
          ],
          "type": "string",
          "default": "base32",
          "description": "Encoding scheme. Used by: encode, decode."
        },
        "padding": {
          "type": "boolean",
          "default": true,
          "description": "Base32/Base32hex: emit = padding. Used by: encode."
        },
        "delimiters": {
          "type": "boolean",
          "default": false,
          "description": "Ascii85: wrap in <~ ~>. Used by: encode."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "description": "encode — Encode UTF-8 text in the chosen scheme. decode — Decode to UTF-8 text (binary payloads are returned as hex)."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "encode: The plain text to encode. decode: The encoded text to decode."
    },
    "options": {
      "type": "object",
      "properties": {
        "format": {
          "enum": [
            "base64",
            "base64url",
            "base32",
            "base58",
            "base85",
            "hex"
          ],
          "type": "string",
          "default": "base64",
          "description": "encode: Target encoding format. decode: Source encoding format. Used by: encode, decode."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "description": "encode — Encode text into the chosen format. decode — Decode text from the chosen format back to plain text."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "hash: The plaintext password to hash. verify: The plaintext password to check."
    },
    "options": {
      "type": "object",
      "properties": {
        "hash": {
          "type": "string",
          "maxLength": 60,
          "description": "The bcrypt hash to compare against (cost 4 or lower over the API). Used by: verify. Required by: verify."
        },
        "rounds": {
          "type": "integer",
          "default": 4,
          "maximum": 4,
          "minimum": 4,
          "description": "Cost factor (log2 of the rounds). The API runs cost 4 to 4; higher costs run in the browser at /tools/bcrypt. Used by: hash."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "hash",
        "verify"
      ],
      "type": "string",
      "description": "hash — Hash a password with bcrypt at the given cost. verify — Verify a plaintext password against a bcrypt hash."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 8192,
      "description": "convert: The text to convert. all: The text to convert."
    },
    "options": {
      "type": "object",
      "properties": {
        "format": {
          "enum": [
            "lower",
            "upper",
            "title",
            "sentence",
            "camel",
            "pascal",
            "snake",
            "kebab",
            "constant",
            "dot",
            "path",
            "toggle"
          ],
          "type": "string",
          "default": "camel",
          "description": "Target case format. Used by: convert."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "convert",
        "all"
      ],
      "type": "string",
      "description": "convert — Convert text to a single chosen case. all — Return every supported case transform at once."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 1024,
      "description": "the text to inspect"
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "inspect"
      ],
      "type": "string",
      "description": "inspect — Inspect each character of a string (code point, category, bytes)."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "octal-to-symbolic: Octal permission string, e.g. \"755\" or \"0644\". symbolic-to-octal: Symbolic permission string, e.g. \"rwxr-xr-x\"."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "octal-to-symbolic",
        "symbolic-to-octal"
      ],
      "type": "string",
      "description": "octal-to-symbolic — Convert octal permissions (e.g. \"755\") to a symbolic string and description. symbolic-to-octal — Convert a symbolic permission string (e.g. \"rwxr-xr-x\") to octal."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "A CIDR block, e.g. \"192.168.1.0/24\"."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "calculate"
      ],
      "type": "string",
      "description": "calculate — Calculate the network, broadcast, mask and host range for a CIDR block."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "convert: A hex color, e.g. \"#3b82f6\". palette: A hex color, e.g. \"#3b82f6\"."
    },
    "options": {
      "type": "object",
      "properties": {
        "type": {
          "enum": [
            "complementary",
            "analogous",
            "triadic",
            "split-complementary",
            "tetradic"
          ],
          "type": "string",
          "default": "complementary",
          "description": "Palette type. Used by: palette."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "convert",
        "palette"
      ],
      "type": "string",
      "description": "convert — Convert a HEX color to every supported color space. palette — Generate a color harmony palette from a base color."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "A hex color, e.g. \"#3b82f6\"."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "generate"
      ],
      "type": "string",
      "description": "generate — Generate harmony, shade and tint palettes from a base HEX color."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "compress: The text to compress. decompress: The compressed bytes, as Base64 or hex."
    },
    "options": {
      "type": "object",
      "properties": {
        "encoding": {
          "enum": [
            "base64",
            "hex"
          ],
          "type": "string",
          "default": "base64",
          "description": "How the compressed bytes are written. Used by: compress, decompress."
        },
        "algorithm": {
          "enum": [
            "gzip",
            "deflate",
            "deflate-raw",
            "auto"
          ],
          "type": "string",
          "description": "compress: gzip (RFC 1952), deflate = zlib (RFC 1950) or deflate-raw (RFC 1951). decompress: auto reads the format from the first bytes. Used by: compress, decompress."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "compress",
        "decompress"
      ],
      "type": "string",
      "description": "compress — Compress UTF-8 text with gzip, deflate (zlib) or raw deflate. decompress — Decompress Base64 or hex gzip/deflate data back to text (output up to 256 KB)."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "check: The foreground color (#rrggbb, #rgb or rgb(...)). best-text: The background color."
    },
    "options": {
      "type": "object",
      "properties": {
        "background": {
          "type": "string",
          "maxLength": 32768,
          "description": "The background color. Used by: check. Required by: check."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "check",
        "best-text"
      ],
      "type": "string",
      "description": "check — Compute the contrast ratio and WCAG pass/fail for a color pair. best-text — Pick black or white text for the best contrast on a background."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "describe: A 5- or 6-field cron expression. next-runs: A 5- or 6-field cron expression."
    },
    "options": {
      "type": "object",
      "properties": {
        "count": {
          "type": "integer",
          "default": 5,
          "maximum": 20,
          "minimum": 1,
          "description": "How many runs to return. Used by: next-runs."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "describe",
        "next-runs"
      ],
      "type": "string",
      "description": "describe — Produce a human-readable description of a cron expression. next-runs — Compute the next N run times for a cron expression."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "evaluate: A CSP header value (optionally with the \"Content-Security-Policy:\" name). harden: A CSP header value."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "evaluate",
        "harden"
      ],
      "type": "string",
      "description": "evaluate — Parse a CSP header and return its directives and findings by severity. harden — Add the low-risk directives a policy is missing (object-src 'none', base-uri, frame-ancestors, form-action) and return ready-to-paste header, meta, nginx and Apache forms."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "minify: The CSS to minify. beautify: The CSS to beautify."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "minify",
        "beautify"
      ],
      "type": "string",
      "description": "minify — Minify CSS (strip comments and whitespace). beautify — Beautify CSS (one declaration per line, indented)."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "the numeric value to convert"
    },
    "options": {
      "type": "object",
      "properties": {
        "to": {
          "enum": [
            "px",
            "rem",
            "em",
            "pt",
            "pc",
            "%"
          ],
          "type": "string",
          "description": "Target unit. Used by: convert. Required by: convert."
        },
        "from": {
          "enum": [
            "px",
            "rem",
            "em",
            "pt",
            "pc",
            "%"
          ],
          "type": "string",
          "description": "Source unit. Used by: convert. Required by: convert."
        },
        "baseFontSize": {
          "type": "number",
          "description": "root font size in px (default 16) Used by: convert."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "convert"
      ],
      "type": "string",
      "description": "convert — Convert a numeric value from one CSS unit to another."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "The curl command to convert."
    },
    "options": {
      "type": "object",
      "properties": {
        "target": {
          "enum": [
            "fetch",
            "python",
            "node",
            "all"
          ],
          "type": "string",
          "default": "fetch",
          "description": "Output language. Used by: convert."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "convert"
      ],
      "type": "string",
      "description": "convert — Parse a curl command and generate code snippets."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "a data size like \"1.5 GB\" or \"1024 KiB\""
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "convert"
      ],
      "type": "string",
      "description": "convert — Parse a data size and convert it to bytes, decimal and binary units."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "diff: Start date (YYYY-MM-DD). add: The date (YYYY-MM-DD). info: The date (YYYY-MM-DD). elapsed: Start as \"YYYY-MM-DD HH:MM\"."
    },
    "options": {
      "type": "object",
      "properties": {
        "end": {
          "type": "string",
          "maxLength": 32768,
          "description": "diff: End date (YYYY-MM-DD). elapsed: End as \"YYYY-MM-DD HH:MM\". Used by: diff, elapsed. Required by: diff, elapsed."
        },
        "duration": {
          "type": "string",
          "maxLength": 32768,
          "description": "e.g. \"30d\", \"1y 6m\", \"-2w\", \"P1M\". Used by: add."
        },
        "holidays": {
          "type": "string",
          "maxLength": 32768,
          "description": "diff: Comma-separated YYYY-MM-DD dates excluded from business days. add: Comma-separated holidays for businessDays. Used by: diff, add."
        },
        "timeZone": {
          "type": "string",
          "maxLength": 32768,
          "description": "info: IANA zone for the midnight timestamp. elapsed: IANA zone of the start. Used by: info, elapsed."
        },
        "endTimeZone": {
          "type": "string",
          "maxLength": 32768,
          "description": "IANA zone of the end (default: same). Used by: elapsed."
        },
        "businessDays": {
          "type": "integer",
          "maximum": 1000,
          "minimum": -1000,
          "description": "Business days to add (negative to subtract), up to 1,000. Used by: add."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "diff",
        "add",
        "info",
        "elapsed"
      ],
      "type": "string",
      "description": "diff — Difference between two dates in years/months/days, total days, weeks and business days. add — Add or subtract a duration (\"1y 2m\", \"-90d\", \"P2W\") or a number of business days. info — Weekday, day of year, ISO week, quarter and leap year for a date (plus Unix time of local midnight). elapsed — Exact elapsed time between two local date-times, following DST in each time zone."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 8192,
      "description": "compare: The original text. unified: The original text."
    },
    "options": {
      "type": "object",
      "properties": {
        "modified": {
          "type": "string",
          "maxLength": 8192,
          "description": "The modified text. Used by: compare, unified. Required by: compare, unified."
        },
        "ignoreCase": {
          "type": "boolean",
          "default": false,
          "description": "Ignore case. Used by: compare."
        },
        "ignoreBlankLines": {
          "type": "boolean",
          "default": false,
          "description": "Ignore blank lines. Used by: compare."
        },
        "ignoreWhitespace": {
          "type": "boolean",
          "default": false,
          "description": "Ignore all whitespace. Used by: compare."
        },
        "ignoreTrailingWhitespace": {
          "type": "boolean",
          "default": false,
          "description": "Ignore whitespace at line ends. Used by: compare."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "compare",
        "unified"
      ],
      "type": "string",
      "description": "compare — Diff two texts and return the lines plus statistics. unified — Produce a unified-diff text between two inputs."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 8192,
      "description": "to-compose: docker run commands; separate several with a blank line, ; or &&. to-run: A Compose file in YAML, or a single service mapping."
    },
    "options": {
      "type": "object",
      "properties": {
        "detach": {
          "type": "boolean",
          "default": true,
          "description": "Add -d so each container runs in the background, as Compose does. Used by: to-run."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "to-compose",
        "to-run"
      ],
      "type": "string",
      "description": "to-compose — Convert one or more docker run commands to Compose services (ports, volumes, env, name, restart, network, command). to-run — Convert a Compose file (or one service) to a docker run command per service."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "convert: A duration in any supported format. to-iso: A duration in any supported format. humanize: A duration in any supported format."
    },
    "options": {
      "type": "object",
      "properties": {
        "weeks": {
          "type": "boolean",
          "default": false,
          "description": "Use PnW when the value is whole weeks. Used by: to-iso."
        },
        "compact": {
          "type": "boolean",
          "default": false,
          "description": "Use 1h 30m instead of words. Used by: humanize."
        },
        "calendarUnits": {
          "type": "boolean",
          "default": false,
          "description": "Use years (365 d) and months (30 d). Used by: to-iso."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "convert",
        "to-iso",
        "humanize"
      ],
      "type": "string",
      "description": "convert — Parse any duration (ISO 8601, 1h30m, 90 minutes, 1:30:00, seconds) into every representation. to-iso — Convert any duration to a canonical ISO 8601 duration string. humanize — Render a duration as words (\"1 hour 30 minutes\") or compact text (\"1h 30m\")."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "to-json: The .env file contents. to-env: A JSON object; nested objects are flattened (DB__HOST). validate: The .env file contents."
    },
    "options": {
      "type": "object",
      "properties": {
        "indent": {
          "type": "integer",
          "default": 2,
          "maximum": 8,
          "minimum": 0,
          "description": "JSON indent in spaces. Used by: to-json."
        },
        "sortKeys": {
          "type": "boolean",
          "default": false,
          "description": "Sort keys alphabetically. Used by: to-env."
        },
        "separator": {
          "type": "string",
          "default": "__",
          "maxLength": 32768,
          "description": "Separator for nested keys. Used by: to-env."
        },
        "uppercase": {
          "type": "boolean",
          "default": false,
          "description": "Upper-case keys. Used by: to-env."
        },
        "coerceTypes": {
          "type": "boolean",
          "default": false,
          "description": "Turn true/false/null and plain numbers into JSON types. Used by: to-json."
        },
        "exportPrefix": {
          "type": "boolean",
          "default": false,
          "description": "Prefix lines with export. Used by: to-env."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "to-json",
        "to-env",
        "validate"
      ],
      "type": "string",
      "description": "to-json — Parse a .env file into a JSON object (last duplicate wins). to-env — Write a JSON object as .env lines, quoting values only where needed. validate — Lint a .env file: duplicates, invalid names, unterminated quotes, stray # comments."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "generate: Comma- or space-separated template keys (e.g. \"node,python,macos\"). templates: Unused (pass an empty string)."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "generate",
        "templates"
      ],
      "type": "string",
      "description": "generate — Combine one or more template keys into a .gitignore. templates — List the available .gitignore template keys."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 8192,
      "description": "Paths to test, one per line; end a directory with / (e.g. build/ or src/app.js)."
    },
    "options": {
      "type": "object",
      "properties": {
        "mode": {
          "enum": [
            "gitignore",
            "glob"
          ],
          "type": "string",
          "default": "gitignore",
          "description": "gitignore: git’s rules (last match wins, excluded parents stay excluded); glob: each pattern against the whole path, with {a,b}. Used by: test."
        },
        "patterns": {
          "type": "string",
          "maxLength": 4096,
          "description": "The patterns, one per line, as in a .gitignore file. Used by: test. Required by: test."
        },
        "ignoreCase": {
          "type": "boolean",
          "default": false,
          "description": "Match case-insensitively (core.ignorecase). Used by: test."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "test"
      ],
      "type": "string",
      "description": "test — Match paths against gitignore rules (negation, anchoring, **, directory-only) or plain globs."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "hash: The text to hash. hmac: The text to authenticate."
    },
    "options": {
      "type": "object",
      "properties": {
        "salt": {
          "type": "string",
          "default": "",
          "maxLength": 32768,
          "description": "Optional salt prefixed to the text. Used by: hash."
        },
        "format": {
          "enum": [
            "hex",
            "base64",
            "binary"
          ],
          "type": "string",
          "default": "hex",
          "description": "Output format. Used by: hash, hmac."
        },
        "secret": {
          "type": "string",
          "maxLength": 32768,
          "description": "The HMAC secret key. Used by: hmac. Required by: hmac."
        },
        "algorithm": {
          "enum": [
            "MD5",
            "SHA-1",
            "SHA-256",
            "SHA-384",
            "SHA-512",
            "CRC32"
          ],
          "type": "string",
          "default": "SHA-256",
          "description": "Hash algorithm. Used by: hash, hmac."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "hash",
        "hmac"
      ],
      "type": "string",
      "description": "hash — Hash text with the chosen algorithm. hmac — Compute an HMAC digest (SHA algorithms only)."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "the message to sign"
    },
    "options": {
      "type": "object",
      "properties": {
        "key": {
          "type": "string",
          "maxLength": 32768,
          "description": "secret key Used by: sign. Required by: sign."
        },
        "algorithm": {
          "enum": [
            "SHA-256",
            "SHA-384",
            "SHA-512"
          ],
          "type": "string",
          "description": "HMAC algorithm. Used by: sign."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "sign"
      ],
      "type": "string",
      "description": "sign — Compute an HMAC signature for a message."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "format: The HTML to format. minify: The HTML to minify. validate: The HTML to validate."
    },
    "options": {
      "type": "object",
      "properties": {
        "indentSize": {
          "type": "integer",
          "default": 2,
          "maximum": 8,
          "minimum": 0,
          "description": "Indent width in spaces. Used by: format."
        },
        "preserveInline": {
          "type": "boolean",
          "default": true,
          "description": "Keep inline elements on one line. Used by: format."
        },
        "wrapAttributes": {
          "type": "boolean",
          "default": false,
          "description": "Put each attribute on its own line. Used by: format."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "format",
        "minify",
        "validate"
      ],
      "type": "string",
      "description": "format — Pretty-print HTML. minify — Minify HTML (strip comments and collapse whitespace). validate — Check HTML for unclosed/mismatched tags."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "encode: The text to encode. decode: The text containing HTML entities."
    },
    "options": {
      "type": "object",
      "properties": {
        "format": {
          "enum": [
            "named",
            "decimal",
            "hex"
          ],
          "type": "string",
          "default": "named",
          "description": "Output entity format. Used by: encode."
        },
        "encodeAll": {
          "type": "boolean",
          "default": false,
          "description": "Encode every character. Used by: encode."
        },
        "preferNamed": {
          "type": "boolean",
          "default": true,
          "description": "Prefer a named entity when one exists. Used by: encode."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "description": "encode — Encode text into HTML entities. decode — Decode HTML entities back to plain text."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "HTML or SVG markup."
    },
    "options": {
      "type": "object",
      "properties": {
        "indent": {
          "type": "integer",
          "default": 2,
          "maximum": 8,
          "minimum": 1,
          "description": "Spaces per indent level. Used by: convert."
        },
        "component": {
          "type": "string",
          "maxLength": 32768,
          "description": "Wrap the JSX in `export default function <Name>()`. Used by: convert."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "convert"
      ],
      "type": "string",
      "description": "convert — Convert an HTML fragment or document to JSX, with warnings for anything to review."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 24000,
      "description": "The HTML to convert (a whole page or a fragment)."
    },
    "options": {
      "type": "object",
      "properties": {
        "scope": {
          "enum": [
            "main",
            "all"
          ],
          "type": "string",
          "default": "main",
          "description": "main: convert only the first <main> (or <article>) when the page has one; all: the whole body. Used by: convert."
        },
        "images": {
          "type": "boolean",
          "default": true,
          "description": "Keep images as ![alt](src); false writes only their alt text. Used by: convert."
        },
        "baseUrl": {
          "type": "string",
          "maxLength": 2048,
          "description": "Absolute URL to resolve relative links and images against. Used by: convert."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "convert"
      ],
      "type": "string",
      "description": "convert — Convert an HTML page or fragment to Markdown: headings, lists, links, images, code blocks, tables and blockquotes."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "lookup: The numeric status code, e.g. \"404\". search: A search query, e.g. \"redirect\" or \"40\"."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "lookup",
        "search"
      ],
      "type": "string",
      "description": "lookup — Look up a single status code by number. search — Search status codes by number, name or description."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 8192,
      "description": "One or more IDs, one per line."
    },
    "options": {
      "type": "object",
      "properties": {
        "kind": {
          "enum": [
            "auto",
            "uuid",
            "ulid",
            "typeid",
            "ksuid",
            "objectid",
            "snowflake",
            "cuid2"
          ],
          "type": "string",
          "default": "auto",
          "description": "Force a format instead of detecting it from the shape. Used by: decode."
        },
        "epoch": {
          "enum": [
            "twitter",
            "discord"
          ],
          "type": "string",
          "default": "discord",
          "description": "Which epoch to read Snowflake IDs with. Used by: decode."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "decode"
      ],
      "type": "string",
      "description": "decode — Detect each ID's format and take it apart (one ID per line, up to 200)."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 1100,
      "description": "A decimal number, Infinity/NaN, 0x + 8 or 16 hex digits, or 32/64 bits."
    },
    "options": {
      "type": "object",
      "properties": {
        "format": {
          "enum": [
            "both",
            "float32",
            "float64"
          ],
          "type": "string",
          "default": "both",
          "description": "Which binary format(s) to show. Used by: inspect."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "inspect"
      ],
      "type": "string",
      "description": "inspect — Read a decimal (0.1, -2.5e-8, Infinity, NaN) or a bit pattern (0x3DCCCCCD, 32 or 64 binary digits) and show how float32 and float64 store it."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "A base64 data URI, e.g. \"data:image/png;base64,...\"."
    },
    "options": {
      "type": "object",
      "properties": {
        "alt": {
          "type": "string",
          "default": "",
          "maxLength": 32768,
          "description": "Alt text for the image. Used by: build-snippets."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "build-snippets"
      ],
      "type": "string",
      "description": "build-snippets — Build HTML/CSS/Markdown snippets from an existing data URI."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "analyze: An IPv6 address (2001:db8::1, fe80::1%eth0, [::1]:443), prefix (2001:db8::/32) or range (2001:db8:: - 2001:db8::ff). compress: One or more IPv6 addresses, one per line. expand: One or more IPv6 addresses, one per line."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "analyze",
        "compress",
        "expand"
      ],
      "type": "string",
      "description": "analyze — Analyse an address, prefix or range: canonical and expanded forms, type, embedded IPv4, network bounds, reverse DNS. compress — Rewrite each address in its RFC 5952 canonical (shortest) form. expand — Rewrite each address with all eight 4-digit groups."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "format: The JSON text to format. minify: The JSON text to minify. validate: The JSON text to validate. repair: The malformed JSON text to repair."
    },
    "options": {
      "type": "object",
      "properties": {
        "indent": {
          "type": "integer",
          "default": 2,
          "maximum": 8,
          "minimum": 0,
          "description": "Number of spaces to indent. Used by: format."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "format",
        "minify",
        "validate",
        "repair"
      ],
      "type": "string",
      "description": "format — Pretty-print JSON with a configurable indent. minify — Strip all insignificant whitespace from JSON. validate — Check whether the input is valid JSON, reporting the error location. repair — Best-effort repair of common JSON mistakes (trailing commas, single quotes, unquoted keys)."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "json-to-csv: The JSON text to convert. csv-to-json: The CSV text to convert."
    },
    "options": {
      "type": "object",
      "properties": {
        "delimiter": {
          "type": "string",
          "default": ",",
          "maxLength": 32768,
          "description": "Field delimiter. Used by: json-to-csv, csv-to-json."
        },
        "includeHeaders": {
          "type": "boolean",
          "default": true,
          "description": "Emit a header row. Used by: json-to-csv."
        },
        "nestedHandling": {
          "enum": [
            "flatten",
            "stringify"
          ],
          "type": "string",
          "default": "flatten",
          "description": "How to handle nested objects. Used by: json-to-csv."
        },
        "firstRowHeaders": {
          "type": "boolean",
          "default": true,
          "description": "Treat the first row as headers. Used by: csv-to-json."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "json-to-csv",
        "csv-to-json"
      ],
      "type": "string",
      "description": "json-to-csv — Convert a JSON array/object to CSV. csv-to-json — Convert CSV to a JSON array."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "the first JSON document"
    },
    "options": {
      "type": "object",
      "properties": {
        "compareTo": {
          "type": "string",
          "maxLength": 32768,
          "description": "the second JSON document to compare against Used by: diff. Required by: diff."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "diff"
      ],
      "type": "string",
      "description": "diff — Diff two JSON documents by path."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "the sample JSON"
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "generate"
      ],
      "type": "string",
      "description": "generate — Infer a draft-07 JSON Schema from sample JSON"
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 8192,
      "description": "The JSON data (instance) to validate."
    },
    "options": {
      "type": "object",
      "properties": {
        "draft": {
          "enum": [
            "auto",
            "2020-12",
            "2019-09",
            "7",
            "4"
          ],
          "type": "string",
          "default": "auto",
          "description": "Schema draft. \"auto\" reads $schema and falls back to 2020-12. Used by: validate."
        },
        "schema": {
          "type": "string",
          "maxLength": 16384,
          "description": "The JSON Schema, as JSON text. Self-contained: $ref may point inside it ($defs, definitions) but remote schemas are not fetched. Used by: validate. Required by: validate."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "validate"
      ],
      "type": "string",
      "description": "validate — Validate JSON data against a JSON Schema."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "The JSON sample to convert."
    },
    "options": {
      "type": "object",
      "properties": {
        "rootName": {
          "type": "string",
          "default": "Root",
          "maxLength": 32768,
          "description": "Root declaration name. Used by: generate."
        },
        "useInterfaces": {
          "type": "boolean",
          "default": true,
          "description": "Emit interfaces (true) or type aliases (false). Used by: generate."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "generate"
      ],
      "type": "string",
      "description": "generate — Infer TypeScript interfaces/types from JSON."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "to-xml: JSON to convert to XML to-json: XML to convert to JSON"
    },
    "options": {
      "type": "object",
      "properties": {
        "indent": {
          "type": "integer",
          "maximum": 8,
          "minimum": 0,
          "description": "Indent width in spaces. Used by: to-xml."
        },
        "rootName": {
          "type": "string",
          "maxLength": 32768,
          "description": "Root element name. Used by: to-xml."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "to-xml",
        "to-json"
      ],
      "type": "string",
      "description": "to-xml — Convert JSON to XML. to-json — Convert XML to JSON."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "to-json: JSON5, JSONC or JSON text. format: JSON5, JSONC or JSON text. validate: JSON5, JSONC or JSON text."
    },
    "options": {
      "type": "object",
      "properties": {
        "style": {
          "enum": [
            "jsonc",
            "json5"
          ],
          "type": "string",
          "default": "jsonc",
          "description": "jsonc = double quotes; json5 = unquoted keys and single quotes. Used by: format."
        },
        "indent": {
          "type": "integer",
          "default": 2,
          "maximum": 8,
          "minimum": 0,
          "description": "to-json: Spaces per level (0 = minified). format: Spaces per level. Used by: to-json, format."
        },
        "specials": {
          "enum": [
            "null",
            "string",
            "error"
          ],
          "type": "string",
          "default": "null",
          "description": "How to write Infinity / NaN, which JSON cannot represent. Used by: to-json."
        },
        "keepComments": {
          "type": "boolean",
          "default": true,
          "description": "Keep comments. Used by: format."
        },
        "trailingCommas": {
          "type": "boolean",
          "default": false,
          "description": "Add trailing commas. Used by: format."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "to-json",
        "format",
        "validate"
      ],
      "type": "string",
      "description": "to-json — Convert JSON5 / JSONC to strict RFC 8259 JSON. format — Re-print JSON / JSON5 / JSONC tidily as JSONC or JSON5, keeping comments. validate — Check whether text is valid JSON5 and list which non-JSON features it uses."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "the JSON document"
    },
    "options": {
      "type": "object",
      "properties": {
        "path": {
          "type": "string",
          "maxLength": 32768,
          "description": "JSONPath expression, e.g. $..name Used by: query. Required by: query."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "query"
      ],
      "type": "string",
      "description": "query — Evaluate a JSONPath expression against a JSON document."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "The JWT token to decode."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "decode"
      ],
      "type": "string",
      "description": "decode — Decode a JWT into its header, payload and signature."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "the JWT payload as JSON"
    },
    "options": {
      "type": "object",
      "properties": {
        "secret": {
          "type": "string",
          "maxLength": 32768,
          "description": "HMAC signing secret Used by: sign. Required by: sign."
        },
        "algorithm": {
          "enum": [
            "HS256",
            "HS384",
            "HS512"
          ],
          "type": "string",
          "description": "HMAC algorithm. Used by: sign."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "sign"
      ],
      "type": "string",
      "description": "sign — Sign a JSON payload into a JWT using an HMAC secret."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 16384,
      "description": "A -----BEGIN CERTIFICATE REQUEST----- or PUBLIC KEY block, one or more \"ssh-ed25519 AAAA…\" lines, or JWK JSON."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "inspect"
      ],
      "type": "string",
      "description": "inspect — Inspect a PEM CSR or public key, OpenSSH public key lines (authorized_keys, known_hosts) or a JWK / JWK Set."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "Unused (pass an empty string)."
    },
    "options": {
      "type": "object",
      "properties": {
        "count": {
          "type": "integer",
          "default": 3,
          "maximum": 100,
          "minimum": 1,
          "description": "Number of units to generate. Used by: generate."
        },
        "unitType": {
          "enum": [
            "paragraphs",
            "sentences",
            "words"
          ],
          "type": "string",
          "default": "paragraphs",
          "description": "What to count. Used by: generate."
        },
        "customWords": {
          "type": "string",
          "maxLength": 2000,
          "description": "Comma- or space-separated words to use instead of the theme. Used by: generate."
        },
        "generatorType": {
          "enum": [
            "lorem",
            "hipster",
            "bacon",
            "corporate",
            "pirate",
            "zombie"
          ],
          "type": "string",
          "default": "lorem",
          "description": "Word theme. Used by: generate."
        },
        "includeNumbers": {
          "type": "boolean",
          "default": false,
          "description": "Mix numbers into the text. Used by: generate."
        },
        "startWithLorem": {
          "type": "boolean",
          "default": true,
          "description": "Start with the classic \"Lorem ipsum\". Used by: generate."
        },
        "includeSpecialChars": {
          "type": "boolean",
          "default": false,
          "description": "Mix punctuation and symbols into the text. Used by: generate."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "generate"
      ],
      "type": "string",
      "description": "generate — Generate lorem ipsum (or themed) placeholder text."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "validate: A card number, IBAN, ISBN or EAN/UPC (spaces and dashes are ignored). check-digit: The digits without their check digit."
    },
    "options": {
      "type": "object",
      "properties": {
        "type": {
          "enum": [
            "auto",
            "card",
            "iban",
            "isbn",
            "gtin",
            "luhn"
          ],
          "type": "string",
          "default": "auto",
          "description": "Which check to run. Used by: validate."
        },
        "algorithm": {
          "enum": [
            "luhn",
            "gs1"
          ],
          "type": "string",
          "default": "luhn",
          "description": "luhn (cards, IMEI) or gs1 (EAN/UPC/GTIN). Used by: check-digit."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "validate",
        "check-digit"
      ],
      "type": "string",
      "description": "validate — Validate a number, auto-detecting its type or using the one you choose. check-digit — Compute the Luhn or GS1 (EAN/UPC) check digit to append to a payload."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "render: The Markdown to render. toc: The Markdown to scan. stats: The text to analyze."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "render",
        "toc",
        "stats"
      ],
      "type": "string",
      "description": "render — Render GitHub-flavored Markdown to sanitized HTML. toc — Extract a table of contents from Markdown headers. stats — Compute document statistics for Markdown/plain text."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "CSV or TSV rows (first row is the header)"
    },
    "options": {
      "type": "object",
      "properties": {
        "delimiter": {
          "type": "string",
          "maxLength": 32768,
          "description": "field delimiter; auto-detected if omitted Used by: generate."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "generate"
      ],
      "type": "string",
      "description": "generate — Build a Markdown table from delimited rows."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "a file extension (png) or MIME type (image/)"
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "lookup"
      ],
      "type": "string",
      "description": "lookup — Search MIME types by extension or MIME type."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "encode: text to convert to Morse decode: Morse code to convert to text"
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "description": "encode — Convert text to Morse code. decode — Convert Morse code to text."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "generate: A custom alphabet, or empty for the default URL-safe NanoID alphabet. collision: The alphabet (its unique character count is used), or empty for the default."
    },
    "options": {
      "type": "object",
      "properties": {
        "size": {
          "type": [
            "integer",
            "number"
          ],
          "default": 21,
          "description": "Characters per ID. Used by: generate, collision."
        },
        "count": {
          "type": "integer",
          "default": 1,
          "maximum": 100,
          "minimum": 1,
          "description": "How many IDs. Used by: generate."
        },
        "perHour": {
          "type": "number",
          "default": 1000,
          "description": "IDs generated per hour. Used by: collision."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "generate",
        "collision"
      ],
      "type": "string",
      "description": "generate — Generate one or more random IDs (default: 21-char URL-safe NanoID). collision — Estimate how long until a 1% collision chance for an alphabet size, ID length and rate."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "The number to convert (digits valid for the source base)."
    },
    "options": {
      "type": "object",
      "properties": {
        "base": {
          "enum": [
            "2",
            "8",
            "10",
            "16"
          ],
          "type": "number",
          "default": 10,
          "description": "Source base. Used by: convert."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "convert"
      ],
      "type": "string",
      "description": "convert — Convert a number from one base to all supported bases."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "generate: Unused (pass an empty string). strength: The password to evaluate."
    },
    "options": {
      "type": "object",
      "properties": {
        "length": {
          "type": "integer",
          "default": 16,
          "maximum": 1024,
          "minimum": 1,
          "description": "Password length. Used by: generate."
        },
        "numbers": {
          "type": "boolean",
          "default": true,
          "description": "Include 0-9. Used by: generate."
        },
        "symbols": {
          "type": "boolean",
          "default": true,
          "description": "Include symbols. Used by: generate."
        },
        "lowercase": {
          "type": "boolean",
          "default": true,
          "description": "Include a-z. Used by: generate."
        },
        "uppercase": {
          "type": "boolean",
          "default": true,
          "description": "Include A-Z. Used by: generate."
        },
        "customSymbols": {
          "type": "string",
          "maxLength": 100,
          "description": "Symbols to use instead of the default set. Used by: generate."
        },
        "excludeSimilar": {
          "type": "boolean",
          "default": false,
          "description": "Exclude similar characters (il1Lo0O). Used by: generate."
        },
        "excludeAmbiguous": {
          "type": "boolean",
          "default": false,
          "description": "Exclude ambiguous symbols ({}[]()/\\'\"`~,;:.<>). Used by: generate."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "generate",
        "strength"
      ],
      "type": "string",
      "description": "generate — Generate a cryptographically random password. strength — Estimate the entropy and strength bucket of a password."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 1024,
      "description": "The password to analyze."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "analyze"
      ],
      "type": "string",
      "description": "analyze — Analyze a password and estimate its entropy, strength and crack time."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 4096,
      "description": "to-ascii: Domain names, email addresses or URLs, one per line. to-unicode: Domain names, email addresses or URLs with xn-- labels, one per line. encode: The Unicode string to encode. decode: The Punycode string to decode."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "to-ascii",
        "to-unicode",
        "encode",
        "decode"
      ],
      "type": "string",
      "description": "to-ascii — Encode each Unicode label as an xn-- label (one domain, email or URL per line; labels are NFC-normalised and lowercased). to-unicode — Decode each xn-- label back to Unicode (one domain, email or URL per line). encode — Encode one string with the bare RFC 3492 algorithm (no xn-- prefix, case kept). decode — Decode one bare Punycode string (no xn-- prefix) with the RFC 3492 algorithm."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "Unused (pass an empty string)."
    },
    "options": {
      "type": "object",
      "properties": {
        "length": {
          "type": "integer",
          "default": 32,
          "maximum": 4096,
          "minimum": 1,
          "description": "Output length. Used by: generate."
        },
        "pattern": {
          "enum": [
            "random",
            "hex",
            "base64",
            "alphanumeric",
            "numeric",
            "custom"
          ],
          "type": "string",
          "default": "alphanumeric",
          "description": "Character pattern. Used by: generate."
        },
        "customCharset": {
          "type": "string",
          "default": "",
          "maxLength": 32768,
          "description": "Charset used when pattern is \"custom\". Used by: generate."
        },
        "excludeSimilar": {
          "type": "boolean",
          "default": false,
          "description": "Exclude similar characters. Used by: generate."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "generate"
      ],
      "type": "string",
      "description": "generate — Generate a secure random string from a chosen pattern."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 4096,
      "description": "test: The test string to search. replace: The test string to transform."
    },
    "options": {
      "type": "object",
      "properties": {
        "flags": {
          "type": "string",
          "default": "g",
          "maxLength": 32768,
          "description": "Regex flags, e.g. \"gi\". Used by: test, replace."
        },
        "pattern": {
          "type": "string",
          "maxLength": 500,
          "description": "The regex pattern (JavaScript syntax). The API refuses nested quantifiers such as (a+)+, which can take exponential time. Used by: test, replace. Required by: test, replace."
        },
        "replacement": {
          "type": "string",
          "default": "",
          "maxLength": 32768,
          "description": "Replacement text. Used by: replace."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "test",
        "replace"
      ],
      "type": "string",
      "description": "test — Find all matches of a regex pattern in a test string. replace — Replace regex matches in a string."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "build: One item per line: sitemap URLs (https://…) and paths every crawler should skip (/admin/). May be empty. validate-llms: The llms.txt file to check."
    },
    "options": {
      "type": "object",
      "properties": {
        "search": {
          "enum": [
            "allow",
            "block"
          ],
          "type": "string",
          "default": "allow",
          "description": "Search engines and every crawler not named (the * group). Used by: build."
        },
        "aiTrain": {
          "enum": [
            "allow",
            "block"
          ],
          "type": "string",
          "default": "block",
          "description": "Crawlers that collect text to train AI models. Used by: build."
        },
        "aiAnswer": {
          "enum": [
            "allow",
            "block"
          ],
          "type": "string",
          "default": "allow",
          "description": "AI answer engines and assistants that fetch pages to answer a question. Used by: build."
        },
        "contentSignal": {
          "type": "boolean",
          "default": true,
          "description": "Add contentsignals.org Content-Signal lines matching the choices. Used by: build."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "build",
        "validate-llms"
      ],
      "type": "string",
      "description": "build — Build robots.txt: allow or block search engines, AI answer engines/assistants and AI training crawlers (named), with Content-Signal and Sitemap lines. validate-llms — Check an llms.txt file against llmstxt.org: one H1, a > summary, H2 sections of Markdown link lists."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "to-roman: an integer 1-3999 from-roman: a Roman numeral"
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "to-roman",
        "from-roman"
      ],
      "type": "string",
      "description": "to-roman — Convert an integer to a Roman numeral. from-roman — Convert a Roman numeral to an integer."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 16384,
      "description": "The SAMLRequest/SAMLResponse value (Base64 for HTTP-POST, deflate + Base64 for HTTP-Redirect), a URL or form body containing it, or the XML."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "decode"
      ],
      "type": "string",
      "description": "decode — Decode a SAML message and return its issuer, status, NameID, audience, conditions, validity window, attributes and pretty-printed XML. Signatures are reported, never verified."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "Raw response headers, e.g. the output of `curl -sI https://example.com`."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "grade"
      ],
      "type": "string",
      "description": "grade — Grade a raw header block and explain each check."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "The text to slugify."
    },
    "options": {
      "type": "object",
      "properties": {
        "strict": {
          "type": "boolean",
          "default": false,
          "description": "Strip non-ASCII characters. Used by: slugify."
        },
        "lowercase": {
          "type": "boolean",
          "default": true,
          "description": "Lowercase the result. Used by: slugify."
        },
        "maxLength": {
          "type": "number",
          "description": "Maximum slug length. Used by: slugify."
        },
        "separator": {
          "type": "string",
          "default": "-",
          "maxLength": 32768,
          "description": "Word separator. Used by: slugify."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "slugify"
      ],
      "type": "string",
      "description": "slugify — Generate a URL slug from text."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "the text, one item per line"
    },
    "options": {
      "type": "object",
      "properties": {
        "trim": {
          "type": "boolean",
          "description": "Trim whitespace from each line. Used by: process."
        },
        "order": {
          "enum": [
            "asc",
            "desc",
            "reverse"
          ],
          "type": "string",
          "description": "Sort order. Used by: process."
        },
        "numeric": {
          "type": "boolean",
          "description": "Sort numerically. Used by: process."
        },
        "removeEmpty": {
          "type": "boolean",
          "description": "Remove empty lines. Used by: process."
        },
        "caseSensitive": {
          "type": "boolean",
          "description": "Case-sensitive sort/dedupe. Used by: process."
        },
        "removeDuplicates": {
          "type": "boolean",
          "description": "Remove duplicate lines. Used by: process."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "process"
      ],
      "type": "string",
      "description": "process — Sort, deduplicate and clean lines of text."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 4096,
      "description": "beautify: The SQL to beautify. minify: The SQL to minify."
    },
    "options": {
      "type": "object",
      "properties": {
        "indentSize": {
          "type": "integer",
          "default": 2,
          "maximum": 8,
          "minimum": 0,
          "description": "Indent width in spaces. Used by: beautify."
        },
        "uppercaseKeywords": {
          "type": "boolean",
          "default": true,
          "description": "Uppercase SQL keywords. Used by: beautify, minify."
        },
        "lineBreaksBeforeClauses": {
          "type": "boolean",
          "default": true,
          "description": "Start each clause (FROM, WHERE, …) on a new line. Used by: beautify."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "beautify",
        "minify"
      ],
      "type": "string",
      "description": "beautify — Beautify SQL with newlines before clauses. minify — Minify SQL to a single line."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "escape: the text to escape unescape: the text to unescape"
    },
    "options": {
      "type": "object",
      "properties": {
        "mode": {
          "enum": [
            "json",
            "js",
            "html",
            "url",
            "regex"
          ],
          "type": "string",
          "description": "Escape mode. Used by: escape, unescape. Required by: escape, unescape."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "escape",
        "unescape"
      ],
      "type": "string",
      "description": "escape — Escape a string for the chosen context. unescape — Unescape a string from the chosen context."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "encode: SVG markup. decode: A data URI, optionally wrapped in url(\"…\")."
    },
    "options": {
      "type": "object",
      "properties": {
        "shortenColors": {
          "type": "boolean",
          "default": true,
          "description": "Rewrite hex colours to their shortest form (#ff0000 → red). Used by: encode."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "description": "encode — Optimise an SVG and return url-encoded and base64 data URIs, sizes and CSS snippets. decode — Decode a data:image/svg+xml URI (percent-encoded or base64) back to SVG markup."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "scan: The text to inspect. clean: The text to clean."
    },
    "options": {
      "type": "object",
      "properties": {
        "tabs": {
          "enum": [
            "keep",
            "to-spaces",
            "to-tabs"
          ],
          "type": "string",
          "default": "keep",
          "description": "Convert tabs and spaces. Used by: clean."
        },
        "dashes": {
          "type": "boolean",
          "default": false,
          "description": "En/em dashes → - / --. Used by: clean."
        },
        "tabWidth": {
          "type": "integer",
          "default": 4,
          "maximum": 8,
          "minimum": 1,
          "description": "Tab stop width. Used by: clean."
        },
        "keepEmoji": {
          "type": "boolean",
          "default": true,
          "description": "Keep joiners inside emoji and non-Latin scripts. Used by: clean."
        },
        "normalize": {
          "enum": [
            "NFC",
            "NFD",
            "NFKC",
            "NFKD",
            "none"
          ],
          "type": "string",
          "default": "NFC",
          "description": "Unicode normalisation form. Used by: clean."
        },
        "lineEndings": {
          "enum": [
            "lf",
            "crlf",
            "cr",
            "keep"
          ],
          "type": "string",
          "default": "lf",
          "description": "Line-ending style. Used by: clean."
        },
        "smartQuotes": {
          "type": "boolean",
          "default": true,
          "description": "Curly quotes → straight. Used by: clean."
        },
        "trimTrailing": {
          "type": "boolean",
          "default": true,
          "description": "Trim trailing whitespace. Used by: clean."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "scan",
        "clean"
      ],
      "type": "string",
      "description": "scan — Report invisible and special characters, hidden tag-character text, unterminated bidi controls, line endings and normalisation. clean — Apply clean-ups and return the text plus counts of every change."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "to-date: The Unix timestamp in seconds. parse-date: A date or timestamp string (ISO 8601, RFC 2822, Unix, etc.)."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "to-date",
        "parse-date"
      ],
      "type": "string",
      "description": "to-date — Convert a Unix timestamp (seconds) to a full date breakdown. parse-date — Auto-detect and parse a date/timestamp string."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "to-json: A TOML document. to-toml: A JSON object."
    },
    "options": {
      "type": "object",
      "properties": {
        "indent": {
          "type": "integer",
          "default": 2,
          "maximum": 8,
          "minimum": 0,
          "description": "JSON indent in spaces. Used by: to-json."
        },
        "detectDates": {
          "type": "boolean",
          "default": false,
          "description": "Emit RFC 3339 date-time strings as TOML date-times. Used by: to-toml."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "to-json",
        "to-toml"
      ],
      "type": "string",
      "description": "to-json — Parse TOML and return pretty-printed JSON. to-toml — Convert a JSON object to TOML (nulls are dropped with a warning)."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "the base32 secret"
    },
    "options": {
      "type": "object",
      "properties": {
        "digits": {
          "type": "integer",
          "default": 6,
          "maximum": 10,
          "minimum": 6,
          "description": "Number of digits in the code. Used by: generate."
        },
        "period": {
          "type": "integer",
          "default": 30,
          "maximum": 3600,
          "minimum": 1,
          "description": "Time step in seconds. Used by: generate."
        },
        "algorithm": {
          "enum": [
            "SHA-1",
            "SHA-256",
            "SHA-512"
          ],
          "type": "string",
          "description": "HMAC algorithm. Used by: generate."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "generate"
      ],
      "type": "string",
      "description": "generate — Generate the current TOTP code for a base32 secret."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "Unused (pass an empty string)."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "generate"
      ],
      "type": "string",
      "description": "generate — Generate a new ULID."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 2048,
      "description": "parse: The URL to parse. validate: The URL to validate. normalize: The URL to normalize."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "parse",
        "validate",
        "normalize"
      ],
      "type": "string",
      "description": "parse — Break a URL into its component parts. validate — Validate a URL and run basic security/heuristic checks. normalize — Normalize a URL (drop default ports, sort query params, strip trailing slash)."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "encode: The text to encode. decode: The encoded text to decode."
    },
    "options": {
      "type": "object",
      "properties": {
        "type": {
          "enum": [
            "component",
            "uri",
            "full"
          ],
          "type": "string",
          "default": "component",
          "description": "Encoding strategy. Used by: encode."
        },
        "level": {
          "type": "integer",
          "default": 1,
          "maximum": 10,
          "minimum": 1,
          "description": "encode: How many times to encode. decode: How many times to decode. Used by: encode, decode."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "encode",
        "decode"
      ],
      "type": "string",
      "description": "encode — Percent-encode a string. decode — Decode a percent-encoded string."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "The User-Agent string to parse."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "parse"
      ],
      "type": "string",
      "description": "parse — Parse a User-Agent string into browser, engine, OS and device details."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "build: The landing-page URL. parse: A tagged URL. strip: A URL with tracking parameters. batch: Landing-page URLs, one per line."
    },
    "options": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "maxLength": 32768,
          "description": "utm_id — campaign identifier. Used by: build, batch."
        },
        "term": {
          "type": "string",
          "maxLength": 32768,
          "description": "utm_term — paid search keyword. Used by: build, batch."
        },
        "medium": {
          "type": "string",
          "maxLength": 32768,
          "description": "utm_medium — the channel (cpc, email, social…). Used by: build, batch."
        },
        "source": {
          "type": "string",
          "maxLength": 32768,
          "description": "utm_source — where the traffic comes from. Used by: build, batch."
        },
        "content": {
          "type": "string",
          "maxLength": 32768,
          "description": "utm_content — which link or creative. Used by: build, batch."
        },
        "campaign": {
          "type": "string",
          "maxLength": 32768,
          "description": "utm_campaign — the campaign name. Used by: build, batch."
        },
        "normalize": {
          "type": "boolean",
          "default": true,
          "description": "Lowercase values and replace spaces with underscores. Used by: build."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "build",
        "parse",
        "strip",
        "batch"
      ],
      "type": "string",
      "description": "build — Add UTM parameters to a URL, normalising case and spaces, and lint the result. parse — Split a URL into UTM tags, ad click IDs and other parameters, with warnings. strip — Remove utm_* and click-ID parameters (gclid, fbclid, msclkid…) from a URL. batch — Tag many URLs (one per line) with the same UTM parameters."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "v4: Unused (pass an empty string). v3: The name to hash. parse: The UUID to parse."
    },
    "options": {
      "type": "object",
      "properties": {
        "count": {
          "type": "integer",
          "default": 1,
          "maximum": 1000,
          "minimum": 1,
          "description": "How many UUIDs to generate. Used by: v4."
        },
        "format": {
          "enum": [
            "standard",
            "uppercase",
            "no-hyphens",
            "braces",
            "urn"
          ],
          "type": "string",
          "default": "standard",
          "description": "Output format. Used by: v4."
        },
        "namespace": {
          "type": "string",
          "default": "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
          "maxLength": 32768,
          "description": "Namespace UUID. Used by: v3."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "v4",
        "v3",
        "parse"
      ],
      "type": "string",
      "description": "v4 — Generate one or more random (v4) UUIDs. v3 — Generate a name-based (v3 / MD5) UUID. parse — Parse a UUID and report its version, variant and (where present) timestamp."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "The network SSID."
    },
    "options": {
      "type": "object",
      "properties": {
        "hidden": {
          "type": "boolean",
          "default": false,
          "description": "Hidden network flag. Used by: payload."
        },
        "password": {
          "type": "string",
          "default": "",
          "maxLength": 32768,
          "description": "Network password. Used by: payload."
        },
        "encryption": {
          "enum": [
            "WPA",
            "WEP",
            "nopass"
          ],
          "type": "string",
          "default": "WPA",
          "description": "Encryption type. Used by: payload."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "payload"
      ],
      "type": "string",
      "description": "payload — Build the WIFI: payload string a phone scans to auto-join a network."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "count: The text to analyze. readability: The text to analyze. keywords: The text to analyze."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "count",
        "readability",
        "keywords"
      ],
      "type": "string",
      "description": "count — Compute basic text statistics (words, characters, sentences, etc.). readability — Compute readability scores (Flesch, SMOG, Coleman-Liau). keywords — Compute keyword density for the text."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "PEM text (-----BEGIN CERTIFICATE-----) or base64 DER."
    },
    "options": {
      "type": "object",
      "properties": {},
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "decode"
      ],
      "type": "string",
      "description": "decode — Decode every certificate in a PEM bundle (or one bare base64 DER)."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 32768,
      "description": "format: The serialized XML to format. minify: The serialized XML to minify."
    },
    "options": {
      "type": "object",
      "properties": {
        "indent": {
          "enum": [
            "2",
            "4",
            "tab"
          ],
          "type": "string",
          "default": "2",
          "description": "Indent style. Used by: format."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "format",
        "minify"
      ],
      "type": "string",
      "description": "format — Pretty-print XML with the chosen indent (server-safe string transform). minify — Collapse whitespace between XML tags (server-safe string transform)."
    }
  }
}

{
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "input": {
      "type": "string",
      "maxLength": 4096,
      "description": "yaml-to-json: The YAML text to convert. json-to-yaml: The JSON text to convert."
    },
    "options": {
      "type": "object",
      "properties": {
        "indent": {
          "type": "integer",
          "default": 2,
          "maximum": 8,
          "minimum": 0,
          "description": "JSON indent (spaces). Used by: yaml-to-json."
        }
      },
      "description": "Options for the chosen operation (each says which operations use it)."
    },
    "operation": {
      "enum": [
        "yaml-to-json",
        "json-to-yaml"
      ],
      "type": "string",
      "description": "yaml-to-json — Convert YAML to JSON. json-to-yaml — Convert JSON to YAML."
    }
  }
}