schema.json

{
    "$schema": "http://json-schema.org/draft-07/schema#",
    "definitions": {
        "Attribute": {
            "properties": {
                "default": {
                    "description": "The default value of the attribute, if any.\n\nAs attributes are always strings, this is the actual value, not a human\nreadable description.",
                    "type": "string"
                },
                "deprecated": {
                    "description": "Whether the attribute is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description.",
                    "type": "string"
                },
                "fieldName": {
                    "description": "The name of the field this attribute is associated with, if any.",
                    "type": "string"
                },
                "inheritedFrom": {
                    "$ref": "#/definitions/Reference"
                },
                "name": {
                    "type": "string"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                },
                "type": {
                    "$ref": "#/definitions/Type",
                    "description": "The type that the attribute will be serialized/deserialized as."
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "ClassDeclaration": {
            "properties": {
                "deprecated": {
                    "description": "Whether the class or mixin is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description of the class.",
                    "type": "string"
                },
                "kind": {
                    "enum": [
                        "class"
                    ],
                    "type": "string"
                },
                "members": {
                    "items": {
                        "anyOf": [
                            {
                                "$ref": "#/definitions/ClassField"
                            },
                            {
                                "$ref": "#/definitions/ClassMethod"
                            }
                        ]
                    },
                    "type": "array"
                },
                "mixins": {
                    "description": "Any class mixins applied in the extends clause of this class.\n\nIf mixins are applied in the class definition, then the true superclass\nof this class is the result of applying mixins in order to the superclass.\n\nMixins must be listed in order of their application to the superclass or\nprevious mixin application. This means that the innermost mixin is listed\nfirst. This may read backwards from the common order in JavaScript, but\nmatches the order of language used to describe mixin application, like\n\"S with A, B\".",
                    "items": {
                        "$ref": "#/definitions/Reference"
                    },
                    "type": "array"
                },
                "name": {
                    "type": "string"
                },
                "source": {
                    "$ref": "#/definitions/SourceReference"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                },
                "superclass": {
                    "$ref": "#/definitions/Reference",
                    "description": "The superclass of this class.\n\nIf this class is defined with mixin applications, the prototype chain\nincludes the mixin applications and the true superclass is computed\nfrom them."
                }
            },
            "required": [
                "kind",
                "name"
            ],
            "type": "object"
        },
        "ClassField": {
            "properties": {
                "default": {
                    "type": "string"
                },
                "deprecated": {
                    "description": "Whether the property is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description of the field.",
                    "type": "string"
                },
                "inheritedFrom": {
                    "$ref": "#/definitions/Reference"
                },
                "kind": {
                    "enum": [
                        "field"
                    ],
                    "type": "string"
                },
                "name": {
                    "type": "string"
                },
                "privacy": {
                    "$ref": "#/definitions/Privacy"
                },
                "readonly": {
                    "description": "Whether the property is read-only.",
                    "type": "boolean"
                },
                "source": {
                    "$ref": "#/definitions/SourceReference"
                },
                "static": {
                    "type": "boolean"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                },
                "type": {
                    "$ref": "#/definitions/Type"
                }
            },
            "required": [
                "kind",
                "name"
            ],
            "type": "object"
        },
        "ClassMethod": {
            "properties": {
                "deprecated": {
                    "description": "Whether the function is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description.",
                    "type": "string"
                },
                "inheritedFrom": {
                    "$ref": "#/definitions/Reference"
                },
                "kind": {
                    "enum": [
                        "method"
                    ],
                    "type": "string"
                },
                "name": {
                    "type": "string"
                },
                "parameters": {
                    "items": {
                        "$ref": "#/definitions/Parameter"
                    },
                    "type": "array"
                },
                "privacy": {
                    "$ref": "#/definitions/Privacy"
                },
                "return": {
                    "properties": {
                        "description": {
                            "description": "A markdown description.",
                            "type": "string"
                        },
                        "summary": {
                            "description": "A markdown summary suitable for display in a listing.",
                            "type": "string"
                        },
                        "type": {
                            "$ref": "#/definitions/Type"
                        }
                    },
                    "type": "object"
                },
                "source": {
                    "$ref": "#/definitions/SourceReference"
                },
                "static": {
                    "type": "boolean"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                }
            },
            "required": [
                "kind",
                "name"
            ],
            "type": "object"
        },
        "CssCustomProperty": {
            "properties": {
                "default": {
                    "type": "string"
                },
                "deprecated": {
                    "description": "Whether the CSS custom property is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description.",
                    "type": "string"
                },
                "name": {
                    "description": "The name of the property, including leading `--`.",
                    "type": "string"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                },
                "syntax": {
                    "description": "The expected syntax of the defined property. Defaults to \"*\".\n\nThe syntax must be a valid CSS [syntax string](https://developer.mozilla.org/en-US/docs/Web/CSS/@property/syntax)\nas defined in the CSS Properties and Values API.\n\nExamples:\n\n\"<color>\": accepts a color\n\"<length> | <percentage>\": accepts lengths or percentages but not calc expressions with a combination of the two\n\"small | medium | large\": accepts one of these values set as custom idents.\n\"*\": any valid token",
                    "type": "string"
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "CssCustomState": {
            "description": "The description of a CSS Custom State\nhttps://developer.mozilla.org/en-US/docs/Web/API/CustomStateSet",
            "properties": {
                "deprecated": {
                    "description": "Whether the CSS custom state is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description.",
                    "type": "string"
                },
                "name": {
                    "description": "The name of the state. Note: Unlike CSS custom properties, custom states\ndo not have a leading `--`.",
                    "type": "string"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "CssPart": {
            "description": "The description of a CSS Part",
            "properties": {
                "deprecated": {
                    "description": "Whether the CSS shadow part is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description.",
                    "type": "string"
                },
                "name": {
                    "type": "string"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "CustomElementDeclaration": {
            "description": "A description of a custom element class.\n\nCustom elements are JavaScript classes, so this extends from\n`ClassDeclaration` and adds custom-element-specific features like\nattributes, events, and slots.\n\nNote that `tagName` in this interface is optional. Tag names are not\nneccessarily part of a custom element class, but belong to the definition\n(often called the \"registration\") or the `customElements.define()` call.\n\nBecause classes and tag names can only be registered once, there's a\none-to-one relationship between classes and tag names. For ease of use,\nwe allow the tag name here.\n\nSome packages define and register custom elements in separate modules. In\nthese cases one `Module` should contain the `CustomElement` without a\ntagName, and another `Module` should contain the\n`CustomElementExport`.",
            "properties": {
                "attributes": {
                    "description": "The attributes that this element is known to understand.",
                    "items": {
                        "$ref": "#/definitions/Attribute"
                    },
                    "type": "array"
                },
                "cssParts": {
                    "items": {
                        "$ref": "#/definitions/CssPart"
                    },
                    "type": "array"
                },
                "cssProperties": {
                    "items": {
                        "$ref": "#/definitions/CssCustomProperty"
                    },
                    "type": "array"
                },
                "cssStates": {
                    "items": {
                        "$ref": "#/definitions/CssCustomState"
                    },
                    "type": "array"
                },
                "customElement": {
                    "description": "Distinguishes a regular JavaScript class from a\ncustom element class",
                    "enum": [
                        true
                    ],
                    "type": "boolean"
                },
                "demos": {
                    "items": {
                        "$ref": "#/definitions/Demo"
                    },
                    "type": "array"
                },
                "deprecated": {
                    "description": "Whether the class or mixin is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description of the class.",
                    "type": "string"
                },
                "events": {
                    "description": "The events that this element fires.",
                    "items": {
                        "$ref": "#/definitions/Event"
                    },
                    "type": "array"
                },
                "kind": {
                    "enum": [
                        "class"
                    ],
                    "type": "string"
                },
                "members": {
                    "items": {
                        "anyOf": [
                            {
                                "$ref": "#/definitions/ClassField"
                            },
                            {
                                "$ref": "#/definitions/ClassMethod"
                            }
                        ]
                    },
                    "type": "array"
                },
                "mixins": {
                    "description": "Any class mixins applied in the extends clause of this class.\n\nIf mixins are applied in the class definition, then the true superclass\nof this class is the result of applying mixins in order to the superclass.\n\nMixins must be listed in order of their application to the superclass or\nprevious mixin application. This means that the innermost mixin is listed\nfirst. This may read backwards from the common order in JavaScript, but\nmatches the order of language used to describe mixin application, like\n\"S with A, B\".",
                    "items": {
                        "$ref": "#/definitions/Reference"
                    },
                    "type": "array"
                },
                "name": {
                    "type": "string"
                },
                "slots": {
                    "description": "The shadow dom content slots that this element accepts.",
                    "items": {
                        "$ref": "#/definitions/Slot"
                    },
                    "type": "array"
                },
                "source": {
                    "$ref": "#/definitions/SourceReference"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                },
                "superclass": {
                    "$ref": "#/definitions/Reference",
                    "description": "The superclass of this class.\n\nIf this class is defined with mixin applications, the prototype chain\nincludes the mixin applications and the true superclass is computed\nfrom them."
                },
                "tagName": {
                    "description": "An optional tag name that should be specified if this is a\nself-registering element.\n\nSelf-registering elements must also include a CustomElementExport\nin the module's exports.",
                    "type": "string"
                }
            },
            "required": [
                "customElement",
                "kind",
                "name"
            ],
            "type": "object"
        },
        "CustomElementExport": {
            "description": "A global custom element defintion, ie the result of a\n`customElements.define()` call.\n\nThis is represented as an export because a definition makes the element\navailable outside of the module it's defined it.",
            "properties": {
                "declaration": {
                    "$ref": "#/definitions/Reference",
                    "description": "A reference to the class or other declaration that implements the\ncustom element."
                },
                "deprecated": {
                    "description": "Whether the custom-element export is deprecated.\nFor example, a future version will not register the custom element in this file.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "kind": {
                    "enum": [
                        "custom-element-definition"
                    ],
                    "type": "string"
                },
                "name": {
                    "description": "The tag name of the custom element.",
                    "type": "string"
                }
            },
            "required": [
                "declaration",
                "kind",
                "name"
            ],
            "type": "object"
        },
        "CustomElementMixinDeclaration": {
            "description": "A class mixin that also adds custom element related properties.",
            "properties": {
                "attributes": {
                    "description": "The attributes that this element is known to understand.",
                    "items": {
                        "$ref": "#/definitions/Attribute"
                    },
                    "type": "array"
                },
                "cssParts": {
                    "items": {
                        "$ref": "#/definitions/CssPart"
                    },
                    "type": "array"
                },
                "cssProperties": {
                    "items": {
                        "$ref": "#/definitions/CssCustomProperty"
                    },
                    "type": "array"
                },
                "cssStates": {
                    "items": {
                        "$ref": "#/definitions/CssCustomState"
                    },
                    "type": "array"
                },
                "customElement": {
                    "description": "Distinguishes a regular JavaScript class from a\ncustom element class",
                    "enum": [
                        true
                    ],
                    "type": "boolean"
                },
                "demos": {
                    "items": {
                        "$ref": "#/definitions/Demo"
                    },
                    "type": "array"
                },
                "deprecated": {
                    "description": "Whether the class or mixin is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description of the class.",
                    "type": "string"
                },
                "events": {
                    "description": "The events that this element fires.",
                    "items": {
                        "$ref": "#/definitions/Event"
                    },
                    "type": "array"
                },
                "kind": {
                    "enum": [
                        "mixin"
                    ],
                    "type": "string"
                },
                "members": {
                    "items": {
                        "anyOf": [
                            {
                                "$ref": "#/definitions/ClassField"
                            },
                            {
                                "$ref": "#/definitions/ClassMethod"
                            }
                        ]
                    },
                    "type": "array"
                },
                "mixins": {
                    "description": "Any class mixins applied in the extends clause of this class.\n\nIf mixins are applied in the class definition, then the true superclass\nof this class is the result of applying mixins in order to the superclass.\n\nMixins must be listed in order of their application to the superclass or\nprevious mixin application. This means that the innermost mixin is listed\nfirst. This may read backwards from the common order in JavaScript, but\nmatches the order of language used to describe mixin application, like\n\"S with A, B\".",
                    "items": {
                        "$ref": "#/definitions/Reference"
                    },
                    "type": "array"
                },
                "name": {
                    "type": "string"
                },
                "parameters": {
                    "items": {
                        "$ref": "#/definitions/Parameter"
                    },
                    "type": "array"
                },
                "return": {
                    "properties": {
                        "description": {
                            "description": "A markdown description.",
                            "type": "string"
                        },
                        "summary": {
                            "description": "A markdown summary suitable for display in a listing.",
                            "type": "string"
                        },
                        "type": {
                            "$ref": "#/definitions/Type"
                        }
                    },
                    "type": "object"
                },
                "slots": {
                    "description": "The shadow dom content slots that this element accepts.",
                    "items": {
                        "$ref": "#/definitions/Slot"
                    },
                    "type": "array"
                },
                "source": {
                    "$ref": "#/definitions/SourceReference"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                },
                "superclass": {
                    "$ref": "#/definitions/Reference",
                    "description": "The superclass of this class.\n\nIf this class is defined with mixin applications, the prototype chain\nincludes the mixin applications and the true superclass is computed\nfrom them."
                },
                "tagName": {
                    "description": "An optional tag name that should be specified if this is a\nself-registering element.\n\nSelf-registering elements must also include a CustomElementExport\nin the module's exports.",
                    "type": "string"
                }
            },
            "required": [
                "customElement",
                "kind",
                "name"
            ],
            "type": "object"
        },
        "Demo": {
            "properties": {
                "description": {
                    "description": "A markdown description of the demo.",
                    "type": "string"
                },
                "source": {
                    "$ref": "#/definitions/SourceReference"
                },
                "url": {
                    "description": "Relative URL of the demo if it's published with the package. Absolute URL\nif it's hosted.",
                    "type": "string"
                }
            },
            "required": [
                "url"
            ],
            "type": "object"
        },
        "Event": {
            "properties": {
                "deprecated": {
                    "description": "Whether the event is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description.",
                    "type": "string"
                },
                "inheritedFrom": {
                    "$ref": "#/definitions/Reference"
                },
                "name": {
                    "type": "string"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                },
                "type": {
                    "$ref": "#/definitions/Type",
                    "description": "The type of the event object that's fired."
                }
            },
            "required": [
                "name",
                "type"
            ],
            "type": "object"
        },
        "FunctionDeclaration": {
            "properties": {
                "deprecated": {
                    "description": "Whether the function is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description.",
                    "type": "string"
                },
                "kind": {
                    "enum": [
                        "function"
                    ],
                    "type": "string"
                },
                "name": {
                    "type": "string"
                },
                "parameters": {
                    "items": {
                        "$ref": "#/definitions/Parameter"
                    },
                    "type": "array"
                },
                "return": {
                    "properties": {
                        "description": {
                            "description": "A markdown description.",
                            "type": "string"
                        },
                        "summary": {
                            "description": "A markdown summary suitable for display in a listing.",
                            "type": "string"
                        },
                        "type": {
                            "$ref": "#/definitions/Type"
                        }
                    },
                    "type": "object"
                },
                "source": {
                    "$ref": "#/definitions/SourceReference"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                }
            },
            "required": [
                "kind",
                "name"
            ],
            "type": "object"
        },
        "JavaScriptExport": {
            "properties": {
                "declaration": {
                    "$ref": "#/definitions/Reference",
                    "description": "A reference to the exported declaration.\n\nIn the case of aggregating exports, the reference's `module` field must be\ndefined and the `name` field must be `\"*\"`."
                },
                "deprecated": {
                    "description": "Whether the export is deprecated. For example, the name of the export was changed.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "kind": {
                    "enum": [
                        "js"
                    ],
                    "type": "string"
                },
                "name": {
                    "description": "The name of the exported symbol.\n\nJavaScript has a number of ways to export objects which determine the\ncorrect name to use.\n\n- Default exports must use the name \"default\".\n- Named exports use the name that is exported. If the export is renamed\n  with the \"as\" clause, use the exported name.\n- Aggregating exports (`* from`) should use the name `*`",
                    "type": "string"
                }
            },
            "required": [
                "declaration",
                "kind",
                "name"
            ],
            "type": "object"
        },
        "JavaScriptModule": {
            "properties": {
                "declarations": {
                    "description": "The declarations of a module.\n\nFor documentation purposes, all declarations that are reachable from\nexports should be described here. Ie, functions and objects that may be\nproperties of exported objects, or passed as arguments to functions.",
                    "items": {
                        "anyOf": [
                            {
                                "$ref": "#/definitions/ClassDeclaration"
                            },
                            {
                                "$ref": "#/definitions/FunctionDeclaration"
                            },
                            {
                                "$ref": "#/definitions/MixinDeclaration"
                            },
                            {
                                "$ref": "#/definitions/VariableDeclaration"
                            },
                            {
                                "$ref": "#/definitions/CustomElementDeclaration"
                            },
                            {
                                "$ref": "#/definitions/CustomElementMixinDeclaration"
                            }
                        ]
                    },
                    "type": "array"
                },
                "deprecated": {
                    "description": "Whether the module is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description of the module.",
                    "type": "string"
                },
                "exports": {
                    "description": "The exports of a module. This includes JavaScript exports and\ncustom element definitions.",
                    "items": {
                        "anyOf": [
                            {
                                "$ref": "#/definitions/JavaScriptExport"
                            },
                            {
                                "$ref": "#/definitions/CustomElementExport"
                            }
                        ]
                    },
                    "type": "array"
                },
                "kind": {
                    "enum": [
                        "javascript-module"
                    ],
                    "type": "string"
                },
                "path": {
                    "description": "Path to the javascript file needed to be imported.\n(not the path for example to a typescript file.)",
                    "type": "string"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                }
            },
            "required": [
                "kind",
                "path"
            ],
            "type": "object"
        },
        "MixinDeclaration": {
            "description": "A description of a class mixin.\n\nMixins are functions which generate a new subclass of a given superclass.\nThis interfaces describes the class and custom element features that\nare added by the mixin. As such, it extends the CustomElement interface and\nClassLike interface.\n\nSince mixins are functions, it also extends the FunctionLike interface. This\nmeans a mixin is callable, and has parameters and a return type.\n\nThe return type is often hard or impossible to accurately describe in type\nsystems like TypeScript. It requires generics and an `extends` operator\nthat TypeScript lacks. Therefore it's recommended that the return type is\nleft empty. The most common form of a mixin function takes a single\nargument, so consumers of this interface should assume that the return type\nis the single argument subclassed by this declaration.\n\nA mixin should not have a superclass. If a mixins composes other mixins,\nthey should be listed in the `mixins` field.\n\nSee [this article]{@link https://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes/}\nfor more information on the classmixin pattern in JavaScript.",
            "properties": {
                "deprecated": {
                    "description": "Whether the class or mixin is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description of the class.",
                    "type": "string"
                },
                "kind": {
                    "enum": [
                        "mixin"
                    ],
                    "type": "string"
                },
                "members": {
                    "items": {
                        "anyOf": [
                            {
                                "$ref": "#/definitions/ClassField"
                            },
                            {
                                "$ref": "#/definitions/ClassMethod"
                            }
                        ]
                    },
                    "type": "array"
                },
                "mixins": {
                    "description": "Any class mixins applied in the extends clause of this class.\n\nIf mixins are applied in the class definition, then the true superclass\nof this class is the result of applying mixins in order to the superclass.\n\nMixins must be listed in order of their application to the superclass or\nprevious mixin application. This means that the innermost mixin is listed\nfirst. This may read backwards from the common order in JavaScript, but\nmatches the order of language used to describe mixin application, like\n\"S with A, B\".",
                    "items": {
                        "$ref": "#/definitions/Reference"
                    },
                    "type": "array"
                },
                "name": {
                    "type": "string"
                },
                "parameters": {
                    "items": {
                        "$ref": "#/definitions/Parameter"
                    },
                    "type": "array"
                },
                "return": {
                    "properties": {
                        "description": {
                            "description": "A markdown description.",
                            "type": "string"
                        },
                        "summary": {
                            "description": "A markdown summary suitable for display in a listing.",
                            "type": "string"
                        },
                        "type": {
                            "$ref": "#/definitions/Type"
                        }
                    },
                    "type": "object"
                },
                "source": {
                    "$ref": "#/definitions/SourceReference"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                },
                "superclass": {
                    "$ref": "#/definitions/Reference",
                    "description": "The superclass of this class.\n\nIf this class is defined with mixin applications, the prototype chain\nincludes the mixin applications and the true superclass is computed\nfrom them."
                }
            },
            "required": [
                "kind",
                "name"
            ],
            "type": "object"
        },
        "Parameter": {
            "properties": {
                "default": {
                    "type": "string"
                },
                "deprecated": {
                    "description": "Whether the property is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description of the field.",
                    "type": "string"
                },
                "name": {
                    "type": "string"
                },
                "optional": {
                    "description": "Whether the parameter is optional. Undefined implies non-optional.",
                    "type": "boolean"
                },
                "readonly": {
                    "description": "Whether the property is read-only.",
                    "type": "boolean"
                },
                "rest": {
                    "description": "Whether the parameter is a rest parameter. Only the last parameter may be a rest parameter.\nUndefined implies single parameter.",
                    "type": "boolean"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                },
                "type": {
                    "$ref": "#/definitions/Type"
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "Privacy": {
            "enum": [
                "private",
                "protected",
                "public"
            ],
            "type": "string"
        },
        "Reference": {
            "description": "A reference to an export of a module.\n\nAll references are required to be publically accessible, so the canonical\nrepresentation of a reference is the export it's available from.\n\n`package` should generally refer to an npm package name. If `package` is\nundefined then the reference is local to this package. If `module` is\nundefined the reference is local to the containing module.\n\nReferences to global symbols like `Array`, `HTMLElement`, or `Event` should\nuse a `package` name of `\"global:\"`.",
            "properties": {
                "module": {
                    "type": "string"
                },
                "name": {
                    "type": "string"
                },
                "package": {
                    "type": "string"
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "Slot": {
            "properties": {
                "deprecated": {
                    "description": "Whether the slot is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description.",
                    "type": "string"
                },
                "name": {
                    "description": "The slot name, or the empty string for an unnamed slot.",
                    "type": "string"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "SourceReference": {
            "description": "A reference to the source of a declaration or member.",
            "properties": {
                "href": {
                    "description": "An absolute URL to the source (ie. a GitHub URL).",
                    "type": "string"
                }
            },
            "required": [
                "href"
            ],
            "type": "object"
        },
        "Type": {
            "properties": {
                "references": {
                    "description": "An array of references to the types in the type string.\n\nThese references have optional indices into the type string so that tools\ncan understand the references in the type string independently of the type\nsystem and syntax. For example, a documentation viewer could display the\ntype `Array<FooElement | BarElement>` with cross-references to `FooElement`\nand `BarElement` without understanding arrays, generics, or union types.",
                    "items": {
                        "$ref": "#/definitions/TypeReference"
                    },
                    "type": "array"
                },
                "source": {
                    "$ref": "#/definitions/SourceReference"
                },
                "text": {
                    "description": "The full string representation of the type, in whatever type syntax is\nused, such as JSDoc, Closure, or TypeScript.",
                    "type": "string"
                }
            },
            "required": [
                "text"
            ],
            "type": "object"
        },
        "TypeReference": {
            "description": "A reference that is associated with a type string and optionally a range\nwithin the string.\n\nStart and end must both be present or not present. If they're present, they\nare indices into the associated type string. If they are missing, the entire\ntype string is the symbol referenced and the name should match the type\nstring.",
            "properties": {
                "end": {
                    "type": "number"
                },
                "module": {
                    "type": "string"
                },
                "name": {
                    "type": "string"
                },
                "package": {
                    "type": "string"
                },
                "start": {
                    "type": "number"
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "VariableDeclaration": {
            "properties": {
                "default": {
                    "type": "string"
                },
                "deprecated": {
                    "description": "Whether the property is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
                    "type": [
                        "string",
                        "boolean"
                    ]
                },
                "description": {
                    "description": "A markdown description of the field.",
                    "type": "string"
                },
                "kind": {
                    "enum": [
                        "variable"
                    ],
                    "type": "string"
                },
                "name": {
                    "type": "string"
                },
                "readonly": {
                    "description": "Whether the property is read-only.",
                    "type": "boolean"
                },
                "source": {
                    "$ref": "#/definitions/SourceReference"
                },
                "summary": {
                    "description": "A markdown summary suitable for display in a listing.",
                    "type": "string"
                },
                "type": {
                    "$ref": "#/definitions/Type"
                }
            },
            "required": [
                "kind",
                "name"
            ],
            "type": "object"
        }
    },
    "description": "The top-level interface of a custom elements manifest file.\n\nBecause custom elements are JavaScript classes, describing a custom element\nmay require describing arbitrary JavaScript concepts like modules, classes,\nfunctions, etc. So custom elements manifests are capable of documenting\nthe elements in a package, as well as those JavaScript concepts.\n\nThe modules described in a package should be the public entrypoints that\nother packages may import from. Multiple modules may export the same object\nvia re-exports, but in most cases a package should document the single\ncanonical export that should be used.",
    "properties": {
        "deprecated": {
            "description": "Whether the package is deprecated.\nIf the value is a string, it's the reason for the deprecation.",
            "type": [
                "string",
                "boolean"
            ]
        },
        "modules": {
            "description": "An array of the modules this package contains.",
            "items": {
                "$ref": "#/definitions/JavaScriptModule"
            },
            "type": "array"
        },
        "readme": {
            "description": "The Markdown to use for the main readme of this package.\n\nThis can be used to override the readme used by Github or npm if that\nfile contains information irrelevant to custom element catalogs and\ndocumentation viewers.",
            "type": "string"
        },
        "schemaVersion": {
            "description": "The version of the schema used in this file.",
            "type": "string"
        }
    },
    "required": [
        "modules",
        "schemaVersion"
    ],
    "type": "object"
}