{
    "$defs": {
        "Array": {
            "description": "Known size array whose elements are of the same type.",
            "properties": {
                "ty": {
                    "$ref": "#/$defs/Type"
                },
                "t": {
                    "const": "Array",
                    "default": "Array",
                    "title": "T"
                },
                "len": {
                    "title": "Len",
                    "type": "integer"
                }
            },
            "required": [
                "ty",
                "len"
            ],
            "title": "Array",
            "type": "object"
        },
        "BoundedNatArg": {
            "properties": {
                "tya": {
                    "const": "BoundedNat",
                    "default": "BoundedNat",
                    "title": "Tya"
                },
                "n": {
                    "title": "N",
                    "type": "integer"
                }
            },
            "required": [
                "n"
            ],
            "title": "BoundedNatArg",
            "type": "object"
        },
        "BoundedNatParam": {
            "properties": {
                "tp": {
                    "const": "BoundedNat",
                    "default": "BoundedNat",
                    "title": "Tp"
                },
                "bound": {
                    "anyOf": [
                        {
                            "type": "integer"
                        },
                        {
                            "type": "null"
                        }
                    ],
                    "title": "Bound"
                }
            },
            "required": [
                "bound"
            ],
            "title": "BoundedNatParam",
            "type": "object"
        },
        "CFG": {
            "description": "A dataflow node which is defined by a child CFG.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "CFG",
                    "default": "CFG",
                    "title": "Op"
                },
                "signature": {
                    "$ref": "#/$defs/FunctionType"
                }
            },
            "required": [
                "parent"
            ],
            "title": "CFG",
            "type": "object"
        },
        "Call": {
            "description": "Operation to call a function directly. The first port is connected to the def/declare of the function being called directly, with a `Static<FunctionType>` edge. The signature of the remaining ports matches the function being called.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "Call",
                    "default": "Call",
                    "title": "Op"
                },
                "signature": {
                    "$ref": "#/$defs/FunctionType"
                }
            },
            "required": [
                "parent"
            ],
            "title": "Call",
            "type": "object"
        },
        "CallIndirect": {
            "description": "Operation to call a function indirectly. Like call, but the first input is a standard dataflow graph type.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "CallIndirect",
                    "default": "CallIndirect",
                    "title": "Op"
                },
                "signature": {
                    "$ref": "#/$defs/FunctionType"
                }
            },
            "required": [
                "parent"
            ],
            "title": "CallIndirect",
            "type": "object"
        },
        "Case": {
            "description": "Case ops - nodes valid inside Conditional nodes.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "Case",
                    "default": "Case",
                    "title": "Op"
                },
                "signature": {
                    "$ref": "#/$defs/FunctionType"
                }
            },
            "required": [
                "parent"
            ],
            "title": "Case",
            "type": "object"
        },
        "Conditional": {
            "description": "Conditional operation, defined by child `Case` nodes for each branch.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "Conditional",
                    "default": "Conditional",
                    "title": "Op"
                },
                "tuple_sum_rows": {
                    "items": {
                        "items": {
                            "$ref": "#/$defs/Type"
                        },
                        "type": "array"
                    },
                    "title": "Tuple Sum Rows",
                    "type": "array"
                },
                "other_inputs": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Other Inputs",
                    "type": "array"
                },
                "outputs": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Outputs",
                    "type": "array"
                },
                "extension_delta": {
                    "items": {
                        "type": "string"
                    },
                    "title": "Extension Delta",
                    "type": "array"
                }
            },
            "required": [
                "parent"
            ],
            "title": "Conditional",
            "type": "object"
        },
        "Const": {
            "description": "A constant value definition.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "Const",
                    "default": "Const",
                    "title": "Op"
                },
                "value": {
                    "$ref": "#/$defs/Value"
                },
                "typ": {
                    "$ref": "#/$defs/Type"
                }
            },
            "required": [
                "parent",
                "value",
                "typ"
            ],
            "title": "Const",
            "type": "object"
        },
        "CustomOp": {
            "description": "A user-defined operation that can be downcasted by the extensions that define it.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "LeafOp",
                    "default": "LeafOp",
                    "title": "Op"
                },
                "lop": {
                    "const": "CustomOp",
                    "default": "CustomOp",
                    "title": "Lop"
                },
                "extension": {
                    "title": "Extension",
                    "type": "string"
                },
                "op_name": {
                    "title": "Op Name",
                    "type": "string"
                },
                "signature": {
                    "$ref": "#/$defs/FunctionType"
                },
                "description": {
                    "default": "",
                    "title": "Description",
                    "type": "string"
                },
                "args": {
                    "items": {
                        "$ref": "#/$defs/TypeArg"
                    },
                    "title": "Args",
                    "type": "array"
                }
            },
            "required": [
                "parent",
                "extension",
                "op_name"
            ],
            "title": "CustomOp",
            "type": "object"
        },
        "CustomTypeArg": {
            "properties": {
                "typ": {
                    "title": "Typ",
                    "type": "null"
                },
                "value": {
                    "title": "Value",
                    "type": "string"
                }
            },
            "required": [
                "typ",
                "value"
            ],
            "title": "CustomTypeArg",
            "type": "object"
        },
        "DFG": {
            "description": "A simply nested dataflow graph.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "DFG",
                    "default": "DFG",
                    "title": "Op"
                },
                "signature": {
                    "$ref": "#/$defs/FunctionType"
                }
            },
            "required": [
                "parent"
            ],
            "title": "DFG",
            "type": "object"
        },
        "DataflowBlock": {
            "description": "A CFG basic block node. The signature is that of the internal Dataflow graph.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "DataflowBlock",
                    "default": "DataflowBlock",
                    "title": "Op"
                },
                "inputs": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Inputs",
                    "type": "array"
                },
                "other_outputs": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Other Outputs",
                    "type": "array"
                },
                "tuple_sum_rows": {
                    "items": {
                        "items": {
                            "$ref": "#/$defs/Type"
                        },
                        "type": "array"
                    },
                    "title": "Tuple Sum Rows",
                    "type": "array"
                },
                "extension_delta": {
                    "items": {
                        "type": "string"
                    },
                    "title": "Extension Delta",
                    "type": "array"
                }
            },
            "required": [
                "parent"
            ],
            "title": "DataflowBlock",
            "type": "object"
        },
        "ExitBlock": {
            "description": "The single exit node of the CFG, has no children, stores the types of the CFG node output.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "ExitBlock",
                    "default": "ExitBlock",
                    "title": "Op"
                },
                "cfg_outputs": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Cfg Outputs",
                    "type": "array"
                }
            },
            "required": [
                "parent",
                "cfg_outputs"
            ],
            "title": "ExitBlock",
            "type": "object"
        },
        "ExtensionVal": {
            "description": "An extension constant value, that can check it is of a given [CustomType].",
            "properties": {
                "v": {
                    "const": "Extension",
                    "default": "Extension",
                    "title": "V"
                },
                "c": {
                    "maxItems": 1,
                    "minItems": 1,
                    "prefixItems": [
                        {}
                    ],
                    "title": "C",
                    "type": "array"
                }
            },
            "required": [
                "c"
            ],
            "title": "ExtensionVal",
            "type": "object"
        },
        "ExtensionsArg": {
            "properties": {
                "tya": {
                    "const": "Extensions",
                    "default": "Extensions",
                    "title": "Tya"
                },
                "es": {
                    "items": {
                        "type": "string"
                    },
                    "title": "Es",
                    "type": "array"
                }
            },
            "required": [
                "es"
            ],
            "title": "ExtensionsArg",
            "type": "object"
        },
        "FuncDecl": {
            "description": "External function declaration, linked at runtime.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "FuncDecl",
                    "default": "FuncDecl",
                    "title": "Op"
                },
                "name": {
                    "title": "Name",
                    "type": "string"
                },
                "signature": {
                    "$ref": "#/$defs/PolyFuncType"
                }
            },
            "required": [
                "parent",
                "name"
            ],
            "title": "FuncDecl",
            "type": "object"
        },
        "FuncDefn": {
            "description": "A function definition. Children nodes are the body of the definition.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "FuncDefn",
                    "default": "FuncDefn",
                    "title": "Op"
                },
                "name": {
                    "title": "Name",
                    "type": "string"
                },
                "signature": {
                    "$ref": "#/$defs/PolyFuncType"
                }
            },
            "required": [
                "parent",
                "name"
            ],
            "title": "FuncDefn",
            "type": "object"
        },
        "FunctionType": {
            "description": "A graph encoded as a value. It contains a concrete signature and a set of required resources.",
            "properties": {
                "input": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Input",
                    "type": "array"
                },
                "output": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Output",
                    "type": "array"
                },
                "extension_reqs": {
                    "items": {
                        "type": "string"
                    },
                    "title": "Extension Reqs",
                    "type": "array"
                }
            },
            "required": [
                "input",
                "output"
            ],
            "title": "FunctionType",
            "type": "object"
        },
        "FunctionVal": {
            "description": "A higher-order function value.",
            "properties": {
                "v": {
                    "const": "Function",
                    "default": "Function",
                    "title": "V"
                },
                "hugr": {
                    "title": "Hugr"
                }
            },
            "required": [
                "hugr"
            ],
            "title": "FunctionVal",
            "type": "object"
        },
        "GeneralSum": {
            "description": "General sum type that explicitly stores the types of the variants.",
            "properties": {
                "t": {
                    "const": "Sum",
                    "default": "Sum",
                    "title": "T"
                },
                "s": {
                    "const": "General",
                    "default": "General",
                    "title": "S"
                },
                "row": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Row",
                    "type": "array"
                }
            },
            "required": [
                "row"
            ],
            "title": "GeneralSum",
            "type": "object"
        },
        "Input": {
            "description": "An input node. The outputs of this node are the inputs to the parent node.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "Input",
                    "default": "Input",
                    "title": "Op"
                },
                "types": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Types",
                    "type": "array"
                }
            },
            "required": [
                "parent"
            ],
            "title": "Input",
            "type": "object"
        },
        "InputExtensions": {
            "anyOf": [
                {
                    "items": {
                        "type": "string"
                    },
                    "type": "array"
                },
                {
                    "type": "null"
                }
            ],
            "default": null
        },
        "USize": {
            "description": "Unsigned integer size type.",
            "properties": {
                "t": {
                    "const": "I",
                    "default": "I",
                    "title": "T"
                }
            },
            "title": "USize",
            "type": "object"
        },
        "LeafOp": {
            "discriminator": {
                "mapping": {
                    "CustomOp": "#/$defs/CustomOp",
                    "MakeTuple": "#/$defs/MakeTuple",
                    "Noop": "#/$defs/Noop",
                    "Tag": "#/$defs/Tag",
                    "TypeApply": "#/$defs/TypeApply",
                    "UnpackTuple": "#/$defs/UnpackTuple"
                },
                "propertyName": "lop"
            },
            "oneOf": [
                {
                    "$ref": "#/$defs/CustomOp"
                },
                {
                    "$ref": "#/$defs/Noop"
                },
                {
                    "$ref": "#/$defs/MakeTuple"
                },
                {
                    "$ref": "#/$defs/UnpackTuple"
                },
                {
                    "$ref": "#/$defs/Tag"
                },
                {
                    "$ref": "#/$defs/TypeApply"
                }
            ]
        },
        "ListParam": {
            "properties": {
                "tp": {
                    "const": "List",
                    "default": "List",
                    "title": "Tp"
                },
                "param": {
                    "$ref": "#/$defs/TypeParam"
                }
            },
            "required": [
                "param"
            ],
            "title": "ListParam",
            "type": "object"
        },
        "LoadConstant": {
            "description": "An operation that loads a static constant in to the local dataflow graph.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "LoadConstant",
                    "default": "LoadConstant",
                    "title": "Op"
                },
                "datatype": {
                    "$ref": "#/$defs/Type"
                }
            },
            "required": [
                "parent",
                "datatype"
            ],
            "title": "LoadConstant",
            "type": "object"
        },
        "MakeTuple": {
            "description": "An operation that packs all its inputs into a tuple.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "LeafOp",
                    "default": "LeafOp",
                    "title": "Op"
                },
                "lop": {
                    "const": "MakeTuple",
                    "default": "MakeTuple",
                    "title": "Lop"
                },
                "tys": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Tys",
                    "type": "array"
                }
            },
            "required": [
                "parent"
            ],
            "title": "MakeTuple",
            "type": "object"
        },
        "Module": {
            "description": "The root of a module, parent of all other `ModuleOp`s.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "Module",
                    "default": "Module",
                    "title": "Op"
                }
            },
            "required": [
                "parent"
            ],
            "title": "Module",
            "type": "object"
        },
        "Noop": {
            "description": "A no-op operation.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "LeafOp",
                    "default": "LeafOp",
                    "title": "Op"
                },
                "lop": {
                    "const": "Noop",
                    "default": "Noop",
                    "title": "Lop"
                },
                "ty": {
                    "$ref": "#/$defs/Type"
                }
            },
            "required": [
                "parent",
                "ty"
            ],
            "title": "Noop",
            "type": "object"
        },
        "OpType": {
            "discriminator": {
                "mapping": {
                    "CFG": "#/$defs/CFG",
                    "Call": "#/$defs/Call",
                    "CallIndirect": "#/$defs/CallIndirect",
                    "Case": "#/$defs/Case",
                    "Conditional": "#/$defs/Conditional",
                    "Const": "#/$defs/Const",
                    "DFG": "#/$defs/DFG",
                    "DataflowBlock": "#/$defs/DataflowBlock",
                    "DummyOp": "#/$defs/DummyOp",
                    "ExitBlock": "#/$defs/ExitBlock",
                    "FuncDecl": "#/$defs/FuncDecl",
                    "FuncDefn": "#/$defs/FuncDefn",
                    "Input": "#/$defs/Input",
                    "LeafOp": "#/$defs/LeafOp",
                    "LoadConstant": "#/$defs/LoadConstant",
                    "Module": "#/$defs/Module",
                    "Output": "#/$defs/Output",
                    "TailLoop": "#/$defs/TailLoop"
                },
                "propertyName": "op"
            },
            "oneOf": [
                {
                    "$ref": "#/$defs/Module"
                },
                {
                    "$ref": "#/$defs/Case"
                },
                {
                    "$ref": "#/$defs/FuncDefn"
                },
                {
                    "$ref": "#/$defs/FuncDecl"
                },
                {
                    "$ref": "#/$defs/Const"
                },
                {
                    "$ref": "#/$defs/DummyOp"
                },
                {
                    "$ref": "#/$defs/DataflowBlock"
                },
                {
                    "$ref": "#/$defs/ExitBlock"
                },
                {
                    "$ref": "#/$defs/Conditional"
                },
                {
                    "$ref": "#/$defs/TailLoop"
                },
                {
                    "$ref": "#/$defs/CFG"
                },
                {
                    "$ref": "#/$defs/Input"
                },
                {
                    "$ref": "#/$defs/Output"
                },
                {
                    "$ref": "#/$defs/Call"
                },
                {
                    "$ref": "#/$defs/CallIndirect"
                },
                {
                    "$ref": "#/$defs/LoadConstant"
                },
                {
                    "$ref": "#/$defs/LeafOp"
                },
                {
                    "$ref": "#/$defs/DFG"
                }
            ]
        },
        "Opaque": {
            "description": "An opaque operation that can be downcasted by the extensions that define it.",
            "properties": {
                "t": {
                    "const": "Opaque",
                    "default": "Opaque",
                    "title": "T"
                },
                "extension": {
                    "title": "Extension",
                    "type": "string"
                },
                "id": {
                    "title": "Id",
                    "type": "string"
                },
                "args": {
                    "items": {
                        "$ref": "#/$defs/TypeArg"
                    },
                    "title": "Args",
                    "type": "array"
                },
                "bound": {
                    "$ref": "#/$defs/TypeBound"
                }
            },
            "required": [
                "extension",
                "id",
                "args",
                "bound"
            ],
            "title": "Opaque",
            "type": "object"
        },
        "OpaqueArg": {
            "properties": {
                "tya": {
                    "const": "Opaque",
                    "default": "Opaque",
                    "title": "Tya"
                },
                "arg": {
                    "$ref": "#/$defs/CustomTypeArg"
                }
            },
            "required": [
                "arg"
            ],
            "title": "OpaqueArg",
            "type": "object"
        },
        "OpaqueParam": {
            "properties": {
                "tp": {
                    "const": "Opaque",
                    "default": "Opaque",
                    "title": "Tp"
                },
                "ty": {
                    "$ref": "#/$defs/Opaque"
                }
            },
            "required": [
                "ty"
            ],
            "title": "OpaqueParam",
            "type": "object"
        },
        "Output": {
            "description": "An output node. The inputs are the outputs of the function.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "Output",
                    "default": "Output",
                    "title": "Op"
                },
                "types": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Types",
                    "type": "array"
                }
            },
            "required": [
                "parent"
            ],
            "title": "Output",
            "type": "object"
        },
        "PolyFuncType": {
            "description": "A graph encoded as a value. It contains a concrete signature and a set of required resources.",
            "properties": {
                "t": {
                    "const": "G",
                    "default": "G",
                    "title": "T"
                },
                "params": {
                    "items": {
                        "$ref": "#/$defs/TypeParam"
                    },
                    "title": "Params",
                    "type": "array"
                },
                "body": {
                    "$ref": "#/$defs/FunctionType"
                }
            },
            "required": [
                "params",
                "body"
            ],
            "title": "PolyFuncType",
            "type": "object"
        },
        "Qubit": {
            "description": "A qubit.",
            "properties": {
                "t": {
                    "const": "Q",
                    "default": "Q",
                    "title": "T"
                }
            },
            "title": "Qubit",
            "type": "object"
        },
        "SequenceArg": {
            "properties": {
                "tya": {
                    "const": "Sequence",
                    "default": "Sequence",
                    "title": "Tya"
                },
                "args": {
                    "items": {
                        "$ref": "#/$defs/TypeArg"
                    },
                    "title": "Args",
                    "type": "array"
                }
            },
            "required": [
                "args"
            ],
            "title": "SequenceArg",
            "type": "object"
        },
        "Sum": {
            "description": "A Sum variant For any Sum type where this value meets the type of the variant indicated by the tag.",
            "properties": {
                "v": {
                    "const": "Sum",
                    "default": "Sum",
                    "title": "V"
                },
                "tag": {
                    "title": "Tag",
                    "type": "integer"
                },
                "value": {
                    "$ref": "#/$defs/Value"
                }
            },
            "required": [
                "tag",
                "value"
            ],
            "title": "Sum",
            "type": "object"
        },
        "Tag": {
            "description": "An operation that creates a tagged sum value from one of its variants.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "LeafOp",
                    "default": "LeafOp",
                    "title": "Op"
                },
                "lop": {
                    "const": "Tag",
                    "default": "Tag",
                    "title": "Lop"
                },
                "tag": {
                    "title": "Tag",
                    "type": "integer"
                },
                "variants": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Variants",
                    "type": "array"
                }
            },
            "required": [
                "parent",
                "tag",
                "variants"
            ],
            "title": "Tag",
            "type": "object"
        },
        "TailLoop": {
            "description": "Tail-controlled loop.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "TailLoop",
                    "default": "TailLoop",
                    "title": "Op"
                },
                "just_inputs": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Just Inputs",
                    "type": "array"
                },
                "just_outputs": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Just Outputs",
                    "type": "array"
                },
                "rest": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Rest",
                    "type": "array"
                }
            },
            "required": [
                "parent"
            ],
            "title": "TailLoop",
            "type": "object"
        },
        "Tuple": {
            "description": "A tuple.",
            "properties": {
                "v": {
                    "const": "Tuple",
                    "default": "Tuple",
                    "title": "V"
                },
                "vs": {
                    "items": {
                        "$ref": "#/$defs/Value"
                    },
                    "title": "Vs",
                    "type": "array"
                }
            },
            "required": [
                "vs"
            ],
            "title": "Tuple",
            "type": "object"
        },
        "TupleParam": {
            "properties": {
                "tp": {
                    "const": "Tuple",
                    "default": "Tuple",
                    "title": "Tp"
                },
                "params": {
                    "items": {
                        "$ref": "#/$defs/TypeParam"
                    },
                    "title": "Params",
                    "type": "array"
                }
            },
            "required": [
                "params"
            ],
            "title": "TupleParam",
            "type": "object"
        },
        "TupleType": {
            "description": "Product type, known-size tuple over elements of type row.",
            "properties": {
                "t": {
                    "const": "Tuple",
                    "default": "Tuple",
                    "title": "T"
                },
                "inner": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Inner",
                    "type": "array"
                }
            },
            "required": [
                "inner"
            ],
            "title": "TupleType",
            "type": "object"
        },
        "SumType": {
            "discriminator": {
                "mapping": {
                    "General": "#/$defs/GeneralSum",
                    "Unit": "#/$defs/UnitSum"
                },
                "propertyName": "s"
            },
            "oneOf": [
                {
                    "$ref": "#/$defs/UnitSum"
                },
                {
                    "$ref": "#/$defs/GeneralSum"
                }
            ]
        },
        "Type": {
            "discriminator": {
                "mapping": {
                    "Array": "#/$defs/Array",
                    "G": "#/$defs/PolyFuncType",
                    "I": "#/$defs/USize",
                    "Opaque": "#/$defs/Opaque",
                    "Q": "#/$defs/Qubit",
                    "Sum": "#/$defs/SumType",
                    "Tuple": "#/$defs/TupleType",
                    "V": "#/$defs/Variable"
                },
                "propertyName": "t"
            },
            "oneOf": [
                {
                    "$ref": "#/$defs/Qubit"
                },
                {
                    "$ref": "#/$defs/Variable"
                },
                {
                    "$ref": "#/$defs/USize"
                },
                {
                    "$ref": "#/$defs/PolyFuncType"
                },
                {
                    "$ref": "#/$defs/Array"
                },
                {
                    "$ref": "#/$defs/TupleType"
                },
                {
                    "$ref": "#/$defs/SumType"
                },
                {
                    "$ref": "#/$defs/Opaque"
                }
            ]
        },
        "TypeApplication": {
            "description": "Records details of an application of a PolyFuncType to some TypeArgs and the result (a less-, but still potentially-, polymorphic type).",
            "properties": {
                "input": {
                    "$ref": "#/$defs/PolyFuncType"
                },
                "args": {
                    "items": {
                        "$ref": "#/$defs/TypeTypeArg"
                    },
                    "title": "Args",
                    "type": "array"
                },
                "output": {
                    "$ref": "#/$defs/PolyFuncType"
                }
            },
            "required": [
                "input",
                "args",
                "output"
            ],
            "title": "TypeApplication",
            "type": "object"
        },
        "TypeApply": {
            "description": "Fixes some TypeParams of a polymorphic type by providing TypeArgs.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "LeafOp",
                    "default": "LeafOp",
                    "title": "Op"
                },
                "lop": {
                    "const": "TypeApply",
                    "default": "TypeApply",
                    "title": "Lop"
                },
                "ta": {
                    "$ref": "#/$defs/TypeApplication"
                }
            },
            "required": [
                "parent",
                "ta"
            ],
            "title": "TypeApply",
            "type": "object"
        },
        "TypeArg": {
            "discriminator": {
                "mapping": {
                    "BoundedNat": "#/$defs/BoundedNatArg",
                    "Extensions": "#/$defs/ExtensionsArg",
                    "Opaque": "#/$defs/OpaqueArg",
                    "Sequence": "#/$defs/SequenceArg",
                    "Type": "#/$defs/TypeTypeArg"
                },
                "propertyName": "tya"
            },
            "oneOf": [
                {
                    "$ref": "#/$defs/TypeTypeArg"
                },
                {
                    "$ref": "#/$defs/BoundedNatArg"
                },
                {
                    "$ref": "#/$defs/OpaqueArg"
                },
                {
                    "$ref": "#/$defs/SequenceArg"
                },
                {
                    "$ref": "#/$defs/ExtensionsArg"
                }
            ]
        },
        "TypeBound": {
            "enum": [
                "E",
                "C",
                "A"
            ],
            "title": "TypeBound",
            "type": "string"
        },
        "TypeParam": {
            "discriminator": {
                "mapping": {
                    "BoundedNat": "#/$defs/BoundedNatParam",
                    "List": "#/$defs/ListParam",
                    "Opaque": "#/$defs/OpaqueParam",
                    "Tuple": "#/$defs/TupleParam",
                    "Type": "#/$defs/TypeTypeParam"
                },
                "propertyName": "tp"
            },
            "oneOf": [
                {
                    "$ref": "#/$defs/TypeTypeParam"
                },
                {
                    "$ref": "#/$defs/BoundedNatParam"
                },
                {
                    "$ref": "#/$defs/OpaqueParam"
                },
                {
                    "$ref": "#/$defs/ListParam"
                },
                {
                    "$ref": "#/$defs/TupleParam"
                }
            ]
        },
        "TypeTypeArg": {
            "properties": {
                "tya": {
                    "const": "Type",
                    "default": "Type",
                    "title": "Tya"
                },
                "ty": {
                    "$ref": "#/$defs/Type"
                }
            },
            "required": [
                "ty"
            ],
            "title": "TypeTypeArg",
            "type": "object"
        },
        "TypeTypeParam": {
            "properties": {
                "tp": {
                    "const": "Type",
                    "default": "Type",
                    "title": "Tp"
                },
                "b": {
                    "$ref": "#/$defs/TypeBound"
                }
            },
            "required": [
                "b"
            ],
            "title": "TypeTypeParam",
            "type": "object"
        },
        "UnitSum": {
            "description": "Simple predicate where all variants are empty tuples.",
            "properties": {
                "t": {
                    "const": "Sum",
                    "default": "Sum",
                    "title": "T"
                },
                "s": {
                    "const": "Unit",
                    "default": "Unit",
                    "title": "S"
                },
                "size": {
                    "title": "Size",
                    "type": "integer"
                }
            },
            "required": [
                "size"
            ],
            "title": "UnitSum",
            "type": "object"
        },
        "UnpackTuple": {
            "description": "An operation that packs all its inputs into a tuple.",
            "properties": {
                "parent": {
                    "title": "Parent",
                    "type": "integer"
                },
                "input_extensions": {
                    "$ref": "#/$defs/InputExtensions"
                },
                "op": {
                    "const": "LeafOp",
                    "default": "LeafOp",
                    "title": "Op"
                },
                "lop": {
                    "const": "UnpackTuple",
                    "default": "UnpackTuple",
                    "title": "Lop"
                },
                "tys": {
                    "items": {
                        "$ref": "#/$defs/Type"
                    },
                    "title": "Tys",
                    "type": "array"
                }
            },
            "required": [
                "parent"
            ],
            "title": "UnpackTuple",
            "type": "object"
        },
        "Value": {
            "anyOf": [
                {
                    "$ref": "#/$defs/ExtensionVal"
                },
                {
                    "$ref": "#/$defs/FunctionVal"
                },
                {
                    "$ref": "#/$defs/Tuple"
                },
                {
                    "$ref": "#/$defs/Sum"
                }
            ]
        },
        "Variable": {
            "description": "A type variable identified by a de Bruijn index.",
            "properties": {
                "t": {
                    "const": "V",
                    "default": "V",
                    "title": "T"
                },
                "i": {
                    "title": "I",
                    "type": "integer"
                },
                "b": {
                    "$ref": "#/$defs/TypeBound"
                }
            },
            "required": [
                "i",
                "b"
            ],
            "title": "Variable",
            "type": "object"
        }
    },
    "properties": {
        "version": {
            "const": "v0",
            "default": "v0",
            "title": "Version"
        },
        "nodes": {
            "items": {
                "$ref": "#/$defs/OpType"
            },
            "title": "Nodes",
            "type": "array"
        },
        "edges": {
            "items": {
                "maxItems": 2,
                "minItems": 2,
                "prefixItems": [
                    {
                        "maxItems": 2,
                        "minItems": 2,
                        "prefixItems": [
                            {
                                "type": "integer"
                            },
                            {
                                "anyOf": [
                                    {
                                        "type": "integer"
                                    },
                                    {
                                        "type": "null"
                                    }
                                ]
                            }
                        ],
                        "type": "array"
                    },
                    {
                        "maxItems": 2,
                        "minItems": 2,
                        "prefixItems": [
                            {
                                "type": "integer"
                            },
                            {
                                "anyOf": [
                                    {
                                        "type": "integer"
                                    },
                                    {
                                        "type": "null"
                                    }
                                ]
                            }
                        ],
                        "type": "array"
                    }
                ],
                "type": "array"
            },
            "title": "Edges",
            "type": "array"
        }
    },
    "required": [
        "version",
        "nodes",
        "edges"
    ],
    "title": "Hugr",
    "type": "object"
}