@nikovirtala/projen-constructs 0.2.1 → 0.2.2

package/node_modules/@jsii/spec/schema/jsii-spec.schema.json

@@ -0,0 +1,1110 @@
+{
+    "$ref": "#/definitions/Assembly",
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "definitions": {
+        "Assembly": {
+            "description": "A JSII assembly specification.",
+            "properties": {
+                "author": {
+                    "$ref": "#/definitions/Person",
+                    "description": "The main author of this package."
+                },
+                "bin": {
+                    "additionalProperties": {
+                        "type": "string"
+                    },
+                    "default": "none",
+                    "description": "List of bin-scripts",
+                    "type": "object"
+                },
+                "bundled": {
+                    "additionalProperties": {
+                        "type": "string"
+                    },
+                    "default": "none",
+                    "description": "List if bundled dependencies (these are not expected to be jsii\nassemblies).",
+                    "type": "object"
+                },
+                "contributors": {
+                    "default": "none",
+                    "description": "Additional contributors to this package.",
+                    "items": {
+                        "$ref": "#/definitions/Person"
+                    },
+                    "type": "array"
+                },
+                "dependencies": {
+                    "additionalProperties": {
+                        "type": "string"
+                    },
+                    "default": "none",
+                    "description": "Direct dependencies on other assemblies (with semver), the key is the JSII\nassembly name, and the value is a SemVer expression.",
+                    "type": "object"
+                },
+                "dependencyClosure": {
+                    "additionalProperties": {
+                        "$ref": "#/definitions/DependencyConfiguration"
+                    },
+                    "default": "none",
+                    "description": "Target configuration for all the assemblies that are direct or transitive\ndependencies of this assembly. This is needed to generate correct native\ntype names for any transitively inherited member, in certain languages.",
+                    "type": "object"
+                },
+                "description": {
+                    "description": "Description of the assembly, maps to \"description\" from package.json\nThis is required since some package managers (like Maven) require it.",
+                    "type": "string"
+                },
+                "docs": {
+                    "$ref": "#/definitions/Docs",
+                    "default": "none",
+                    "description": "Documentation for this entity."
+                },
+                "fingerprint": {
+                    "description": "A fingerprint that can be used to determine if the specification has\nchanged.",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "homepage": {
+                    "description": "The url to the project homepage. Maps to \"homepage\" from package.json.",
+                    "type": "string"
+                },
+                "jsiiVersion": {
+                    "description": "The version of the jsii compiler that was used to produce this Assembly.",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "keywords": {
+                    "description": "Keywords that help discover or identify this packages with respects to it's\nintended usage, audience, etc... Where possible, this will be rendered in\nthe corresponding metadata section of idiomatic package manifests, for\nexample NuGet package tags.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "license": {
+                    "description": "The SPDX name of the license this assembly is distributed on.",
+                    "type": "string"
+                },
+                "metadata": {
+                    "additionalProperties": {},
+                    "default": "none",
+                    "description": "Arbitrary key-value pairs of metadata, which the maintainer chose to\ndocument with the assembly. These entries do not carry normative\nsemantics and their interpretation is up to the assembly maintainer.",
+                    "type": "object"
+                },
+                "name": {
+                    "description": "The name of the assembly",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "readme": {
+                    "$ref": "#/definitions/ReadMe",
+                    "default": "none",
+                    "description": "The readme document for this module (if any)."
+                },
+                "repository": {
+                    "description": "The module repository, maps to \"repository\" from package.json\nThis is required since some package managers (like Maven) require it.",
+                    "properties": {
+                        "directory": {
+                            "default": "the root of the repository",
+                            "description": "If the package is not in the root directory (for example, when part\nof a monorepo), you should specify the directory in which it lives.",
+                            "type": "string"
+                        },
+                        "type": {
+                            "description": "The type of the repository (``git``, ``svn``, ...)",
+                            "type": "string"
+                        },
+                        "url": {
+                            "description": "The URL of the repository.",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "type",
+                        "url"
+                    ],
+                    "type": "object"
+                },
+                "schema": {
+                    "const": "jsii/0.10.0",
+                    "description": "The version of the spec schema\n\nNOTE: we cannot ever change this value anymore! If we do, new instances of\nassmblies that would have been backwards compatible with the old schema\nstill cannot be loaded, because the schema versions don't match exactly (as\nvalidated by JSON Schema validators on loading).\n\nWe *must* always emit this value as 'jsii/0.10.0'.\n\nInstead, see `usedFeatures` for a dynamic way to do feature validation\nwithout relying on a fixed schema version.",
+                    "type": "string"
+                },
+                "submodules": {
+                    "additionalProperties": {
+                        "$ref": "#/definitions/Submodule"
+                    },
+                    "default": "none",
+                    "description": "Submodules declared in this assembly.",
+                    "type": "object"
+                },
+                "targets": {
+                    "$ref": "#/definitions/AssemblyTargets",
+                    "default": "none",
+                    "description": "A map of target name to configuration, which is used when generating\npackages for various languages."
+                },
+                "types": {
+                    "additionalProperties": {
+                        "$ref": "#/definitions/Type"
+                    },
+                    "default": "none",
+                    "description": "All types in the assembly, keyed by their fully-qualified-name",
+                    "type": "object"
+                },
+                "usedFeatures": {
+                    "default": "- Only original jsii features.",
+                    "description": "List of features used in this assembly\n\nIf a modern jsii feature is used in the assembly, a descriptive string\nshould be added here. This field will be used to selectively reject the\nloading of assemblies that requires features not currently supported by the\njsii kernel, or downstream jsii tools.",
+                    "items": {
+                        "$ref": "#/definitions/JsiiFeature"
+                    },
+                    "type": "array"
+                },
+                "version": {
+                    "description": "The version of the assembly",
+                    "minLength": 1,
+                    "type": "string"
+                }
+            },
+            "required": [
+                "author",
+                "description",
+                "fingerprint",
+                "homepage",
+                "jsiiVersion",
+                "license",
+                "name",
+                "repository",
+                "schema",
+                "version"
+            ],
+            "type": "object"
+        },
+        "AssemblyTargets": {
+            "additionalProperties": {
+                "additionalProperties": {},
+                "type": "object"
+            },
+            "description": "Configurable targets for an asembly.",
+            "type": "object"
+        },
+        "Callable": {
+            "description": "An Initializer or a Method.",
+            "properties": {
+                "docs": {
+                    "$ref": "#/definitions/Docs",
+                    "default": "none",
+                    "description": "Documentation for this entity."
+                },
+                "locationInModule": {
+                    "$ref": "#/definitions/SourceLocation",
+                    "default": "none",
+                    "description": "Where in the module this definition was found\n\nWhy is this not `locationInAssembly`? Because the assembly is the JSII\nfile combining compiled code and its manifest, whereas this is referring\nto the location of the source in the module the assembly was built from."
+                },
+                "overrides": {
+                    "default": "this member is not overriding anything",
+                    "description": "The FQN of the parent type (class or interface) that this entity\noverrides or implements. If undefined, then this entity is the first in\nit's hierarchy to declare this entity.",
+                    "type": "string"
+                },
+                "parameters": {
+                    "default": "none",
+                    "description": "The parameters of the Initializer or Method.",
+                    "items": {
+                        "$ref": "#/definitions/Parameter"
+                    },
+                    "type": "array"
+                },
+                "protected": {
+                    "default": false,
+                    "description": "Indicates if this Initializer or Method is protected (otherwise it is\npublic, since private members are not modeled).",
+                    "type": "boolean"
+                },
+                "variadic": {
+                    "default": false,
+                    "description": "Indicates whether this Initializer or Method is variadic or not. When\n``true``, the last element of ``#parameters`` will also be flagged\n``#variadic``.",
+                    "type": "boolean"
+                }
+            },
+            "type": "object"
+        },
+        "ClassType": {
+            "description": "Represents classes.",
+            "properties": {
+                "abstract": {
+                    "default": false,
+                    "description": "Indicates if this class is an abstract class.",
+                    "type": "boolean"
+                },
+                "assembly": {
+                    "description": "The name of the assembly the type belongs to.",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "base": {
+                    "default": "no base class",
+                    "description": "The FQN of the base class of this class, if it has one.",
+                    "type": "string"
+                },
+                "docs": {
+                    "$ref": "#/definitions/Docs",
+                    "default": "none",
+                    "description": "Documentation for this entity."
+                },
+                "fqn": {
+                    "description": "The fully qualified name of the type (``<assembly>.<namespace>.<name>``)",
+                    "minLength": 3,
+                    "type": "string"
+                },
+                "initializer": {
+                    "$ref": "#/definitions/Callable",
+                    "default": "no initializer",
+                    "description": "Initializer (constructor) method."
+                },
+                "interfaces": {
+                    "default": "none",
+                    "description": "The FQNs of the interfaces this class implements, if any.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array",
+                    "uniqueItems": true
+                },
+                "kind": {
+                    "const": "class",
+                    "description": "The kind of the type.",
+                    "type": "string"
+                },
+                "locationInModule": {
+                    "$ref": "#/definitions/SourceLocation",
+                    "default": "none",
+                    "description": "Where in the module this definition was found\n\nWhy is this not `locationInAssembly`? Because the assembly is the JSII\nfile combining compiled code and its manifest, whereas this is referring\nto the location of the source in the module the assembly was built from."
+                },
+                "methods": {
+                    "default": "none",
+                    "description": "List of methods.",
+                    "items": {
+                        "$ref": "#/definitions/Method"
+                    },
+                    "type": "array"
+                },
+                "name": {
+                    "description": "The simple name of the type (MyClass).",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "namespace": {
+                    "default": "none",
+                    "description": "The namespace of the type (`foo.bar.baz`).\n\nWhen undefined, the type is located at the root of the assembly (its\n`fqn` would be like `<assembly>.<name>`).\n\nFor types inside other types or inside submodules, the `<namespace>` corresponds to\nthe namespace-qualified name of the container (can contain multiple segments like:\n`<ns1>.<ns2>.<ns3>`).\n\nIn all cases:\n\n <fqn> = <assembly>[.<namespace>].<name>",
+                    "type": "string"
+                },
+                "properties": {
+                    "default": "none",
+                    "description": "List of properties.",
+                    "items": {
+                        "$ref": "#/definitions/Property"
+                    },
+                    "type": "array"
+                },
+                "symbolId": {
+                    "description": "Unique string representation of the corresponding Typescript symbol\n\nUsed to map from TypeScript code back into the assembly.",
+                    "type": "string"
+                }
+            },
+            "required": [
+                "assembly",
+                "fqn",
+                "kind",
+                "name"
+            ],
+            "type": "object"
+        },
+        "CollectionKind": {
+            "description": "Kinds of collections.",
+            "enum": [
+                "array",
+                "map"
+            ],
+            "type": "string"
+        },
+        "CollectionTypeReference": {
+            "description": "Reference to a collection type.",
+            "properties": {
+                "collection": {
+                    "properties": {
+                        "elementtype": {
+                            "$ref": "#/definitions/TypeReference",
+                            "description": "The type of an element (map keys are always strings)."
+                        },
+                        "kind": {
+                            "$ref": "#/definitions/CollectionKind",
+                            "description": "The kind of collection."
+                        }
+                    },
+                    "required": [
+                        "elementtype",
+                        "kind"
+                    ],
+                    "type": "object"
+                }
+            },
+            "required": [
+                "collection"
+            ],
+            "type": "object"
+        },
+        "DependencyConfiguration": {
+            "properties": {
+                "submodules": {
+                    "additionalProperties": {
+                        "$ref": "#/definitions/Targetable"
+                    },
+                    "type": "object"
+                },
+                "targets": {
+                    "$ref": "#/definitions/AssemblyTargets",
+                    "default": "none",
+                    "description": "A map of target name to configuration, which is used when generating\npackages for various languages."
+                }
+            },
+            "type": "object"
+        },
+        "Docs": {
+            "description": "Key value pairs of documentation nodes.\nBased on TSDoc.",
+            "properties": {
+                "custom": {
+                    "additionalProperties": {
+                        "type": "string"
+                    },
+                    "default": "none",
+                    "description": "Custom tags that are not any of the default ones",
+                    "type": "object"
+                },
+                "default": {
+                    "default": "none",
+                    "description": "Description of the default",
+                    "type": "string"
+                },
+                "deprecated": {
+                    "default": "none",
+                    "description": "If present, this block indicates that an API item is no longer supported\nand may be removed in a future release.  The `@deprecated` tag must be\nfollowed by a sentence describing the recommended alternative.\nDeprecation recursively applies to members of a container. For example,\nif a class is deprecated, then so are all of its members.",
+                    "type": "string"
+                },
+                "example": {
+                    "default": "none",
+                    "description": "Example showing the usage of this API item\n\nStarts off in running text mode, may switch to code using fenced code\nblocks.",
+                    "type": "string"
+                },
+                "remarks": {
+                    "default": "none",
+                    "description": "Detailed information about an API item.\n\nEither the explicitly tagged `@remarks` section, otherwise everything\npast the first paragraph if there is no `@remarks` tag.",
+                    "type": "string"
+                },
+                "returns": {
+                    "default": "none",
+                    "description": "The `@returns` block for this doc comment, or undefined if there is not\none.",
+                    "type": "string"
+                },
+                "see": {
+                    "default": "none",
+                    "description": "A `@see` link with more information",
+                    "type": "string"
+                },
+                "stability": {
+                    "description": "Whether the API item is beta/experimental quality",
+                    "enum": [
+                        "deprecated",
+                        "experimental",
+                        "external",
+                        "stable"
+                    ],
+                    "type": "string"
+                },
+                "subclassable": {
+                    "default": false,
+                    "description": "Whether this class or interface was intended to be subclassed/implemented\nby library users.\n\nClasses intended for subclassing, and interfaces intended to be\nimplemented by consumers, are held to stricter standards of API\ncompatibility.",
+                    "type": "boolean"
+                },
+                "summary": {
+                    "default": "none",
+                    "description": "Summary documentation for an API item.\n\nThe first part of the documentation before hitting a `@remarks` tags, or\nthe first line of the doc comment block if there is no `@remarks` tag.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "EnumMember": {
+            "description": "Represents a member of an enum.",
+            "properties": {
+                "docs": {
+                    "$ref": "#/definitions/Docs",
+                    "default": "none",
+                    "description": "Documentation for this entity."
+                },
+                "name": {
+                    "description": "The name/symbol of the member.",
+                    "type": "string"
+                }
+            },
+            "required": [
+                "name"
+            ],
+            "type": "object"
+        },
+        "EnumType": {
+            "description": "Represents an enum type.",
+            "properties": {
+                "assembly": {
+                    "description": "The name of the assembly the type belongs to.",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "docs": {
+                    "$ref": "#/definitions/Docs",
+                    "default": "none",
+                    "description": "Documentation for this entity."
+                },
+                "fqn": {
+                    "description": "The fully qualified name of the type (``<assembly>.<namespace>.<name>``)",
+                    "minLength": 3,
+                    "type": "string"
+                },
+                "kind": {
+                    "const": "enum",
+                    "description": "The kind of the type.",
+                    "type": "string"
+                },
+                "locationInModule": {
+                    "$ref": "#/definitions/SourceLocation",
+                    "default": "none",
+                    "description": "Where in the module this definition was found\n\nWhy is this not `locationInAssembly`? Because the assembly is the JSII\nfile combining compiled code and its manifest, whereas this is referring\nto the location of the source in the module the assembly was built from."
+                },
+                "members": {
+                    "description": "Members of the enum.",
+                    "items": {
+                        "$ref": "#/definitions/EnumMember"
+                    },
+                    "type": "array"
+                },
+                "name": {
+                    "description": "The simple name of the type (MyClass).",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "namespace": {
+                    "default": "none",
+                    "description": "The namespace of the type (`foo.bar.baz`).\n\nWhen undefined, the type is located at the root of the assembly (its\n`fqn` would be like `<assembly>.<name>`).\n\nFor types inside other types or inside submodules, the `<namespace>` corresponds to\nthe namespace-qualified name of the container (can contain multiple segments like:\n`<ns1>.<ns2>.<ns3>`).\n\nIn all cases:\n\n <fqn> = <assembly>[.<namespace>].<name>",
+                    "type": "string"
+                },
+                "symbolId": {
+                    "description": "Unique string representation of the corresponding Typescript symbol\n\nUsed to map from TypeScript code back into the assembly.",
+                    "type": "string"
+                }
+            },
+            "required": [
+                "assembly",
+                "fqn",
+                "kind",
+                "members",
+                "name"
+            ],
+            "type": "object"
+        },
+        "InterfaceType": {
+            "properties": {
+                "assembly": {
+                    "description": "The name of the assembly the type belongs to.",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "datatype": {
+                    "default": false,
+                    "description": "True if this interface only contains properties. Different backends might\nhave idiomatic ways to allow defining concrete instances such interfaces.\nFor example, in Java, the generator will produce a PoJo and a builder\nwhich will allow users to create a concrete object with data which\nadheres to this interface.",
+                    "type": "boolean"
+                },
+                "docs": {
+                    "$ref": "#/definitions/Docs",
+                    "default": "none",
+                    "description": "Documentation for this entity."
+                },
+                "fqn": {
+                    "description": "The fully qualified name of the type (``<assembly>.<namespace>.<name>``)",
+                    "minLength": 3,
+                    "type": "string"
+                },
+                "interfaces": {
+                    "default": "none",
+                    "description": "The FQNs of the interfaces this interface extends, if any.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array",
+                    "uniqueItems": true
+                },
+                "kind": {
+                    "const": "interface",
+                    "description": "The kind of the type.",
+                    "type": "string"
+                },
+                "locationInModule": {
+                    "$ref": "#/definitions/SourceLocation",
+                    "default": "none",
+                    "description": "Where in the module this definition was found\n\nWhy is this not `locationInAssembly`? Because the assembly is the JSII\nfile combining compiled code and its manifest, whereas this is referring\nto the location of the source in the module the assembly was built from."
+                },
+                "methods": {
+                    "default": "none",
+                    "description": "List of methods.",
+                    "items": {
+                        "$ref": "#/definitions/Method"
+                    },
+                    "type": "array"
+                },
+                "name": {
+                    "description": "The simple name of the type (MyClass).",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "namespace": {
+                    "default": "none",
+                    "description": "The namespace of the type (`foo.bar.baz`).\n\nWhen undefined, the type is located at the root of the assembly (its\n`fqn` would be like `<assembly>.<name>`).\n\nFor types inside other types or inside submodules, the `<namespace>` corresponds to\nthe namespace-qualified name of the container (can contain multiple segments like:\n`<ns1>.<ns2>.<ns3>`).\n\nIn all cases:\n\n <fqn> = <assembly>[.<namespace>].<name>",
+                    "type": "string"
+                },
+                "properties": {
+                    "default": "none",
+                    "description": "List of properties.",
+                    "items": {
+                        "$ref": "#/definitions/Property"
+                    },
+                    "type": "array"
+                },
+                "symbolId": {
+                    "description": "Unique string representation of the corresponding Typescript symbol\n\nUsed to map from TypeScript code back into the assembly.",
+                    "type": "string"
+                }
+            },
+            "required": [
+                "assembly",
+                "fqn",
+                "kind",
+                "name"
+            ],
+            "type": "object"
+        },
+        "IntersectionTypeReference": {
+            "description": "Reference to an intersection type.",
+            "properties": {
+                "intersection": {
+                    "description": "Indicates that this is an intersection type, which means it must satisfy all of the given types.",
+                    "properties": {
+                        "types": {
+                            "description": "All the possible types (including the primary type).",
+                            "items": {
+                                "$ref": "#/definitions/TypeReference"
+                            },
+                            "minItems": 2,
+                            "type": "array"
+                        }
+                    },
+                    "required": [
+                        "types"
+                    ],
+                    "type": "object"
+                }
+            },
+            "required": [
+                "intersection"
+            ],
+            "type": "object"
+        },
+        "JsiiFeature": {
+            "description": "Predefined constants for a set of jsii extension features",
+            "enum": [
+                "class-covariant-overrides",
+                "intersection-types"
+            ],
+            "type": "string"
+        },
+        "Method": {
+            "description": "A method with a name (i.e: not an initializer).",
+            "properties": {
+                "abstract": {
+                    "default": false,
+                    "description": "Is this method an abstract method (this means the class will also be an abstract class)",
+                    "type": "boolean"
+                },
+                "async": {
+                    "default": false,
+                    "description": "Indicates if this is an asynchronous method (it will return a promise).",
+                    "type": "boolean"
+                },
+                "docs": {
+                    "$ref": "#/definitions/Docs",
+                    "default": "none",
+                    "description": "Documentation for this entity."
+                },
+                "locationInModule": {
+                    "$ref": "#/definitions/SourceLocation",
+                    "default": "none",
+                    "description": "Where in the module this definition was found\n\nWhy is this not `locationInAssembly`? Because the assembly is the JSII\nfile combining compiled code and its manifest, whereas this is referring\nto the location of the source in the module the assembly was built from."
+                },
+                "name": {
+                    "description": "The name of the method. Undefined if this method is a initializer.",
+                    "type": "string"
+                },
+                "overrides": {
+                    "default": "this member is not overriding anything",
+                    "description": "The FQN of the parent type (class or interface) that this entity\noverrides or implements. If undefined, then this entity is the first in\nit's hierarchy to declare this entity.",
+                    "type": "string"
+                },
+                "parameters": {
+                    "default": "none",
+                    "description": "The parameters of the Initializer or Method.",
+                    "items": {
+                        "$ref": "#/definitions/Parameter"
+                    },
+                    "type": "array"
+                },
+                "protected": {
+                    "default": false,
+                    "description": "Indicates if this Initializer or Method is protected (otherwise it is\npublic, since private members are not modeled).",
+                    "type": "boolean"
+                },
+                "returns": {
+                    "$ref": "#/definitions/OptionalValue",
+                    "default": "void",
+                    "description": "The return type of the method (`undefined` if `void`)"
+                },
+                "static": {
+                    "default": false,
+                    "description": "Indicates if this is a static method.",
+                    "type": "boolean"
+                },
+                "variadic": {
+                    "default": false,
+                    "description": "Indicates whether this Initializer or Method is variadic or not. When\n``true``, the last element of ``#parameters`` will also be flagged\n``#variadic``.",
+                    "type": "boolean"
+                }
+            },
+            "required": [
+                "name"
+            ],
+            "type": "object"
+        },
+        "NamedTypeReference": {
+            "description": "Reference to a named type, defined by this assembly or one of its\ndependencies.",
+            "properties": {
+                "fqn": {
+                    "description": "The fully-qualified-name of the type (can be located in the\n``spec.types[fqn]``` of the assembly that defines the type).",
+                    "type": "string"
+                }
+            },
+            "required": [
+                "fqn"
+            ],
+            "type": "object"
+        },
+        "OptionalValue": {
+            "description": "A value that can possibly be optional.",
+            "properties": {
+                "optional": {
+                    "default": false,
+                    "description": "Determines whether the value is, indeed, optional.",
+                    "type": "boolean"
+                },
+                "type": {
+                    "$ref": "#/definitions/TypeReference",
+                    "description": "The declared type of the value, when it's present."
+                }
+            },
+            "required": [
+                "type"
+            ],
+            "type": "object"
+        },
+        "Parameter": {
+            "description": "Represents a method parameter.",
+            "properties": {
+                "docs": {
+                    "$ref": "#/definitions/Docs",
+                    "default": "none",
+                    "description": "Documentation for this entity."
+                },
+                "name": {
+                    "description": "The name of the parameter.",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "optional": {
+                    "default": false,
+                    "description": "Determines whether the value is, indeed, optional.",
+                    "type": "boolean"
+                },
+                "type": {
+                    "$ref": "#/definitions/TypeReference",
+                    "description": "The declared type of the value, when it's present."
+                },
+                "variadic": {
+                    "default": false,
+                    "description": "Whether this is the last parameter of a variadic method. In such cases,\nthe `#type` attribute is the type of each individual item of the variadic\narguments list (as opposed to some array type, as for example TypeScript\nwould model it).",
+                    "type": "boolean"
+                }
+            },
+            "required": [
+                "name",
+                "type"
+            ],
+            "type": "object"
+        },
+        "Person": {
+            "description": "Metadata about people or organizations associated with the project that\nresulted in the Assembly. Some of this metadata is required in order to\npublish to certain package repositories (for example, Maven Central), but is\nnot normalized, and the meaning of fields (role, for example), is up to each\nproject maintainer.",
+            "properties": {
+                "email": {
+                    "default": "none",
+                    "description": "The email of the person",
+                    "type": "string"
+                },
+                "name": {
+                    "description": "The name of the person",
+                    "type": "string"
+                },
+                "organization": {
+                    "default": false,
+                    "description": "If true, this person is, in fact, an organization",
+                    "type": "boolean"
+                },
+                "roles": {
+                    "description": "A list of roles this person has in the project, for example `maintainer`,\n`contributor`, `owner`, ...",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "url": {
+                    "default": "none",
+                    "description": "The URL for the person",
+                    "type": "string"
+                }
+            },
+            "required": [
+                "name",
+                "roles"
+            ],
+            "type": "object"
+        },
+        "PrimitiveType": {
+            "description": "Kinds of primitive types.",
+            "enum": [
+                "date",
+                "string",
+                "number",
+                "boolean",
+                "json",
+                "any"
+            ],
+            "type": "string"
+        },
+        "PrimitiveTypeReference": {
+            "description": "Reference to a primitive type.",
+            "properties": {
+                "primitive": {
+                    "$ref": "#/definitions/PrimitiveType",
+                    "description": "If this is a reference to a primitive type, this will include the\nprimitive type kind."
+                }
+            },
+            "required": [
+                "primitive"
+            ],
+            "type": "object"
+        },
+        "Property": {
+            "description": "A class property.",
+            "properties": {
+                "abstract": {
+                    "default": false,
+                    "description": "Indicates if this property is abstract",
+                    "type": "boolean"
+                },
+                "const": {
+                    "default": false,
+                    "description": "A hint that indicates that this static, immutable property is initialized\nduring startup. This allows emitting \"const\" idioms in different target\nlanguages. Implies `static` and `immutable`.",
+                    "type": "boolean"
+                },
+                "docs": {
+                    "$ref": "#/definitions/Docs",
+                    "default": "none",
+                    "description": "Documentation for this entity."
+                },
+                "immutable": {
+                    "default": false,
+                    "description": "Indicates if this property only has a getter (immutable).",
+                    "type": "boolean"
+                },
+                "locationInModule": {
+                    "$ref": "#/definitions/SourceLocation",
+                    "default": "none",
+                    "description": "Where in the module this definition was found\n\nWhy is this not `locationInAssembly`? Because the assembly is the JSII\nfile combining compiled code and its manifest, whereas this is referring\nto the location of the source in the module the assembly was built from."
+                },
+                "name": {
+                    "description": "The name of the property.",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "optional": {
+                    "default": false,
+                    "description": "Determines whether the value is, indeed, optional.",
+                    "type": "boolean"
+                },
+                "overrides": {
+                    "default": "this member is not overriding anything",
+                    "description": "The FQN of the parent type (class or interface) that this entity\noverrides or implements. If undefined, then this entity is the first in\nit's hierarchy to declare this entity.",
+                    "type": "string"
+                },
+                "protected": {
+                    "default": false,
+                    "description": "Indicates if this property is protected (otherwise it is public)",
+                    "type": "boolean"
+                },
+                "static": {
+                    "default": false,
+                    "description": "Indicates if this is a static property.",
+                    "type": "boolean"
+                },
+                "type": {
+                    "$ref": "#/definitions/TypeReference",
+                    "description": "The declared type of the value, when it's present."
+                }
+            },
+            "required": [
+                "name",
+                "type"
+            ],
+            "type": "object"
+        },
+        "ReadMe": {
+            "description": "README information",
+            "properties": {
+                "markdown": {
+                    "type": "string"
+                }
+            },
+            "required": [
+                "markdown"
+            ],
+            "type": "object"
+        },
+        "ReadMeContainer": {
+            "description": "Elements that can contain a `readme` property.",
+            "properties": {
+                "readme": {
+                    "$ref": "#/definitions/ReadMe",
+                    "default": "none",
+                    "description": "The readme document for this module (if any)."
+                }
+            },
+            "type": "object"
+        },
+        "SourceLocatable": {
+            "description": "Indicates that an entity has a source location",
+            "properties": {
+                "locationInModule": {
+                    "$ref": "#/definitions/SourceLocation",
+                    "default": "none",
+                    "description": "Where in the module this definition was found\n\nWhy is this not `locationInAssembly`? Because the assembly is the JSII\nfile combining compiled code and its manifest, whereas this is referring\nto the location of the source in the module the assembly was built from."
+                }
+            },
+            "type": "object"
+        },
+        "SourceLocation": {
+            "description": "Where in the module source the definition for this API item was found",
+            "properties": {
+                "filename": {
+                    "description": "Relative filename",
+                    "type": "string"
+                },
+                "line": {
+                    "description": "1-based line number in the indicated file",
+                    "type": "number"
+                }
+            },
+            "required": [
+                "filename",
+                "line"
+            ],
+            "type": "object"
+        },
+        "Submodule": {
+            "allOf": [
+                {
+                    "$ref": "#/definitions/ReadMeContainer"
+                },
+                {
+                    "$ref": "#/definitions/SourceLocatable"
+                },
+                {
+                    "$ref": "#/definitions/Targetable"
+                },
+                {
+                    "$ref": "#/definitions/TypeScriptLocatable"
+                }
+            ],
+            "description": "A submodule\n\nThe difference between a top-level module (the assembly) and a submodule is\nthat the submodule is annotated with its location in the repository."
+        },
+        "Targetable": {
+            "description": "A targetable module-like thing\n\nHas targets and a readme. Used for Assemblies and Submodules.",
+            "properties": {
+                "targets": {
+                    "$ref": "#/definitions/AssemblyTargets",
+                    "default": "none",
+                    "description": "A map of target name to configuration, which is used when generating\npackages for various languages."
+                }
+            },
+            "type": "object"
+        },
+        "Type": {
+            "anyOf": [
+                {
+                    "allOf": [
+                        {
+                            "$ref": "#/definitions/TypeBase"
+                        },
+                        {
+                            "$ref": "#/definitions/ClassType"
+                        }
+                    ]
+                },
+                {
+                    "allOf": [
+                        {
+                            "$ref": "#/definitions/TypeBase"
+                        },
+                        {
+                            "$ref": "#/definitions/EnumType"
+                        }
+                    ]
+                },
+                {
+                    "allOf": [
+                        {
+                            "$ref": "#/definitions/TypeBase"
+                        },
+                        {
+                            "$ref": "#/definitions/InterfaceType"
+                        }
+                    ]
+                }
+            ],
+            "description": "Represents a type definition (not a type reference)."
+        },
+        "TypeBase": {
+            "description": "Common attributes of a type definition.",
+            "properties": {
+                "assembly": {
+                    "description": "The name of the assembly the type belongs to.",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "docs": {
+                    "$ref": "#/definitions/Docs",
+                    "default": "none",
+                    "description": "Documentation for this entity."
+                },
+                "fqn": {
+                    "description": "The fully qualified name of the type (``<assembly>.<namespace>.<name>``)",
+                    "minLength": 3,
+                    "type": "string"
+                },
+                "kind": {
+                    "$ref": "#/definitions/TypeKind",
+                    "description": "The kind of the type."
+                },
+                "locationInModule": {
+                    "$ref": "#/definitions/SourceLocation",
+                    "default": "none",
+                    "description": "Where in the module this definition was found\n\nWhy is this not `locationInAssembly`? Because the assembly is the JSII\nfile combining compiled code and its manifest, whereas this is referring\nto the location of the source in the module the assembly was built from."
+                },
+                "name": {
+                    "description": "The simple name of the type (MyClass).",
+                    "minLength": 1,
+                    "type": "string"
+                },
+                "namespace": {
+                    "default": "none",
+                    "description": "The namespace of the type (`foo.bar.baz`).\n\nWhen undefined, the type is located at the root of the assembly (its\n`fqn` would be like `<assembly>.<name>`).\n\nFor types inside other types or inside submodules, the `<namespace>` corresponds to\nthe namespace-qualified name of the container (can contain multiple segments like:\n`<ns1>.<ns2>.<ns3>`).\n\nIn all cases:\n\n <fqn> = <assembly>[.<namespace>].<name>",
+                    "type": "string"
+                },
+                "symbolId": {
+                    "description": "Unique string representation of the corresponding Typescript symbol\n\nUsed to map from TypeScript code back into the assembly.",
+                    "type": "string"
+                }
+            },
+            "required": [
+                "assembly",
+                "fqn",
+                "kind",
+                "name"
+            ],
+            "type": "object"
+        },
+        "TypeKind": {
+            "description": "Kinds of types.",
+            "enum": [
+                "class",
+                "enum",
+                "interface"
+            ],
+            "type": "string"
+        },
+        "TypeReference": {
+            "anyOf": [
+                {
+                    "$ref": "#/definitions/NamedTypeReference"
+                },
+                {
+                    "$ref": "#/definitions/PrimitiveTypeReference"
+                },
+                {
+                    "$ref": "#/definitions/CollectionTypeReference"
+                },
+                {
+                    "$ref": "#/definitions/UnionTypeReference"
+                },
+                {
+                    "$ref": "#/definitions/IntersectionTypeReference"
+                }
+            ],
+            "description": "A reference to a type (primitive, collection or fqn)."
+        },
+        "TypeScriptLocatable": {
+            "description": "Indicates that a jsii entity's origin can be traced to TypeScript code\n\nThis is interface is not the same as `SourceLocatable`. SourceLocatable\nidentifies lines in source files in a source repository (in a `.ts` file,\nwith respect to a git root).\n\nOn the other hand, `TypeScriptLocatable` identifies a symbol name inside a\npotentially distributed TypeScript file (in either a `.d.ts` or `.ts`\nfile, with respect to the package root).",
+            "properties": {
+                "symbolId": {
+                    "description": "Unique string representation of the corresponding Typescript symbol\n\nUsed to map from TypeScript code back into the assembly.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "UnionTypeReference": {
+            "description": "Reference to a union type.",
+            "properties": {
+                "union": {
+                    "description": "Indicates that this is a union type, which means it can be one of a set\nof types.",
+                    "properties": {
+                        "types": {
+                            "description": "All the possible types (including the primary type).",
+                            "items": {
+                                "$ref": "#/definitions/TypeReference"
+                            },
+                            "minItems": 2,
+                            "type": "array"
+                        }
+                    },
+                    "required": [
+                        "types"
+                    ],
+                    "type": "object"
+                }
+            },
+            "required": [
+                "union"
+            ],
+            "type": "object"
+        }
+    }
+}
+