conf.d/openapi/openapi-schema.json

   1 {
   2         "title": "A JSON Schema for OpenApi 3.0 API.",
   3         "id": "http://www.openapis.org/v3/schema.json#",
   4         "$schema": "http://json-schema.org/draft-04/schema#",
   5         "type": "object",
   6         "required": [
   7                 "openapi",
   8                 "info",
   9                 "paths"
  10         ],
  11         "additionalProperties": false,
  12         "patternProperties": {
  13                 "^X-": {
  14                         "$ref": "#/definitions/vendorExtension"
  15                 }
  16         },
  17         "properties": {
  18                 "openapi": {
  19                         "type": "string",
  20                         "enum": [
  21                                 "3.0.0"
  22                         ],
  23                         "description": "Specifies the OpenAPI Specification version being used. It can be used by tooling Specifications and clients to interpret the version. The structure shall be major.minor.patch, where patch versions must be compatible with the existing major.minor tooling. Typically patch versions will be introduced to address errors in the documentation, and tooling should typically be compatible with the corresponding major.minor (3.0.*). Patch versions will correspond to patches of this document."
  24                 },
  25                 "info": {
  26                         "$ref": "#/definitions/info"
  27                 },
  28                 "servers": {
  29                         "type": "array",
  30                         "items": {
  31                                 "$ref": "#/definitions/server"
  32                         },
  33                         "uniqueItems": true
  34                 },
  35                 "paths": {
  36                         "$ref": "#/definitions/paths"
  37                 },
  38                 "components": {
  39                         "$ref": "#/definitions/components"
  40                 },
  41                 "security": {
  42                         "type": "array",
  43                         "items": {
  44                                 "$ref": "#/definitions/securityRequirement"
  45                         },
  46                         "uniqueItems": true
  47                 },
  48                 "tags": {
  49                         "type": "array",
  50                         "items": {
  51                                 "$ref": "#/definitions/tag"
  52                         },
  53                         "uniqueItems": true
  54                 },
  55                 "externalDocs": {
  56                         "$ref": "#/definitions/externalDocs"
  57                 }
  58         },
  59         "definitions": {
  60                 "vendorExtension": {
  61                         "description": "Any property starting with x- is valid.",
  62                         "additionalProperties": true,
  63                         "additionalItems": true
  64                 },
  65                 "contact": {
  66                         "type": "object",
  67                         "description": "Contact information for the exposed API.",
  68                         "additionalProperties": false,
  69                         "patternProperties": {
  70                                 "^X-": {
  71                                         "$ref": "#/definitions/vendorExtension"
  72                                 }
  73                         },
  74                         "properties": {
  75                                 "name": {
  76                                         "type": "string",
  77                                         "description": "The identifying name of the contact person/organization."
  78                                 },
  79                                 "url": {
  80                                         "type": "string",
  81                                         "description": "The URL pointing to the contact information. MUST be in the format of a URL."
  82                                 },
  83                                 "email": {
  84                                         "type": "string",
  85                                         "description": "The email address of the contact person/organization. Must be in the format of an email address."
  86                                 }
  87                         }
  88                 },
  89                 "license": {
  90                         "type": "object",
  91                         "description": "License information for the exposed API.",
  92                         "required": [ "name" ],
  93                         "additionalProperties": false,
  94                         "patternProperties": {
  95                                 "^X-": {
  96                                         "$ref": "#/definitions/vendorExtension"
  97                                 }
  98                         },
  99                         "properties": {
 100                                 "name": {
 101                                         "type": "string",
 102                                         "description": "The license name used for the API."
 103                                 },
 104                                 "url": {
 105                                         "type": "string",
 106                                         "description": "A URL to the license used for the API. MUST be in the format of a URL."
 107                                 }
 108                         }
 109                 },
 110                 "info": {
 111                         "type": "object",
 112                         "description": "The object provides metadata about the API. The metadata can be used by the clients if needed, and can be presented in the OpenApi-UI for convenience.",
 113                         "required": [
 114                                 "title",
 115                                 "version"
 116                         ],
 117                         "additionalProperties": false,
 118                         "patternProperties": {
 119                                 "^X-": {
 120                                         "$ref": "#/definitions/vendorExtension"
 121                                 }
 122                         },
 123                         "properties": {
 124                                 "title": {
 125                                         "type": "string",
 126                                         "description": "The title of the application."
 127                                 },
 128                                 "description": {
 129                                         "type": "string",
 130                                         "description": "A short description of the application. CommonMark syntax can be used for rich text representation."
 131                                 },
 132                                 "termsOfService": {
 133                                         "type": "string",
 134                                         "description": "A URL to the Terms of Service for the API."
 135                                 },
 136                                 "contact": {
 137                                         "$ref": "#/definitions/contact"
 138                                 },
 139                                 "license": {
 140                                         "$ref": "#/definitions/license"
 141                                 },
 142                                 "version": {
 143                                         "type": "string",
 144                                         "description": "Provides the version of the application API (not to be confused with the specification version)."
 145                                 }
 146                         }
 147                 },
 148                 "server": {
 149                         "type": "object",
 150                         "description": "An object representing a Server.",
 151                         "additionalProperties": false,
 152                         "patternProperties": {
 153                                 "^X-": {
 154                                         "$ref": "#/definitions/vendorExtension"
 155                                 }
 156                         },
 157                         "properties": {
 158                                 "url": {
 159                                         "type": "string",
 160                                         "description": "A absolute URL to the target host. This URL supports template variables and may be relative, to indicate that the host location is relative to the location where the OpenAPI Specification is being served. Templates are optional and specified by the Host Template Parameter syntax. Template substitutions will be made when a variable is named in {brackets}."
 161                                 },
 162                                 "description": {
 163                                         "type": "string",
 164                                         "description": "An optional string describing the host designated by the URL."
 165                                 },
 166                                 "variables": {
 167                                         "$ref": "#/definitions/serverVariables"
 168                                 }
 169                         }
 170                 },
 171                 "paths": {
 172                         "type": "object",
 173                         "description": "Holds the relative paths to the individual endpoints and their operations. The path is appended to the URL from the Server Object in order to construct the full URL. The Paths MAY be empty, due to ACL constraints.",
 174                         "patternProperties": {
 175                                 "^X-": {
 176                                         "$ref": "#/definitions/vendorExtension"
 177                                 },
 178                                 "^/": {
 179                                         "$ref": "#/definitions/pathItem"
 180                                 }
 181                         },
 182                         "additionalProperties": false
 183                 },
 184                 "pathItem": {
 185                         "type": "object",
 186                         "description": "Describes the operations available on a single path. A Path Item MAY be empty, due to ACL constraints. The path itself is still exposed to the documentation viewer but they will not know which operations and parameters are available.",
 187                         "properties": {
 188                                 "$ref": {
 189                                         "type": "string",
 190                                         "description": "Allows for an external definition of this path item. The referenced structure MUST be in the format of a Path Item Object. If there are conflicts between the referenced definition and this Path Item's definition, the behavior is undefined."
 191                                 },
 192                                 "summary": {
 193                                         "type": "string",
 194                                         "description": "An optional, string summary, intended to apply to all operations in this path."
 195                                 },
 196                                 "description": {
 197                                         "type": "string",
 198                                         "description": "An optional, string description, intended to apply to all operations in this path. CommonMark syntax can be used for rich text representation."
 199                                 },
 200                                 "get": {
 201                                         "$ref": "#/definitions/operation"
 202                                 },
 203                                 "put": {
 204                                         "$ref": "#/definitions/operation"
 205                                 },
 206                                 "post": {
 207                                         "$ref": "#/definitions/operation"
 208                                 },
 209                                 "delete": {
 210                                         "$ref": "#/definitions/operation"
 211                                 },
 212                                 "options": {
 213                                         "$ref": "#/definitions/operation"
 214                                 },
 215                                 "head": {
 216                                         "$ref": "#/definitions/operation"
 217                                 },
 218                                 "patch": {
 219                                         "$ref": "#/definitions/operation"
 220                                 },
 221                                 "trace": {
 222                                         "$ref": "#/definitions/operation"
 223                                 },
 224                                 "servers": {
 225                                         "type": "array",
 226                                         "items": {
 227                                                 "$ref": "#/definitions/server"
 228                                         }
 229                                 },
 230                                 "parameters": {
 231                                         "type": "array",
 232                                         "items": {
 233                                                 "oneOf": [
 234                                                         { "$ref": "#/definitions/parameter" },
 235                                                         { "$ref": "#/definitions/reference" }
 236                                                 ]
 237                                         }
 238                                 }
 239                         },
 240                         "patternProperties": {
 241                                 "^X-": {
 242                                         "$ref": "#/definitions/vendorExtension"
 243                                 }
 244                         },
 245                         "additionalProperties": false
 246                 },
 247                 "operation": {
 248                         "type": "object",
 249                         "description": "Describes a single API operation on a path.",
 250                         "required": [ "responses" ],
 251                         "properties": {
 252                                 "tags": {
 253                                         "type": "array",
 254                                         "items": [
 255                                                 { "type": "string" }
 256                                         ],
 257                                         "description": "A list of tags for API documentation control. Tags can be used for logical grouping of operations by resources or any other qualifier."
 258                                 },
 259                                 "summary": {
 260                                         "type": "string",
 261                                         "description": "A short summary of what the operation does. For maximum readability in editing or documentation generation tools, this field SHOULD be less than 120 characters."
 262                                 },
 263                                 "description": {
 264                                         "type": "string",
 265                                         "description": "A verbose explanation of the operation behavior. CommonMark syntax can be used for rich text representation."
 266                                 },
 267                                 "externalDocs": {
 268                                         "$ref": "#/definitions/externalDocs"
 269                                 },
 270                                 "operationId": {
 271                                         "type": "string",
 272                                         "description": "Unique string used to identify the operation. The id MUST be unique among all operations described in the API. Tools and libraries MAY use the operationId to uniquely identify an operation, therefore, it is recommended to follow common programming naming conventions."
 273                                 },
 274                                 "parameters": {
 275                                         "type": "array",
 276                                         "items": {
 277                                                 "oneOf": [
 278                                                         { "$ref": "#/definitions/parameter" },
 279                                                         { "$ref": "#/definitions/reference" }
 280                                                 ]
 281                                         },
 282                                         "description": "A list of parameters that are applicable for this operation. If a parameter is already defined at the Path Item, the new definition will override it but can never remove it. The list MUST NOT include duplicated parameters. A unique parameter is defined by a combination of a name and location. The list can use the Reference Object to link to parameters that are defined at the OpenAPI Object's components/parameters."
 283                                 },
 284                                 "requestBody": {
 285                                         "oneOf": [
 286                                                 { "$ref": "#/definitions/requestBody" },
 287                                                 { "$ref": "#/definitions/reference" }
 288                                         ],
 289                                         "description": "The request body applicable for this operation. The requestBody is only supported in HTTP methods where the HTTP 1.1 specification has explicitly defined semantics for request bodies. In other cases where the HTTP spec is vague, requestBody SHALL be ignored by consumers."
 290                                 },
 291                                 "responses": {
 292                                         "$ref": "#/definitions/responses",
 293                                         "description": "Required. The list of possible responses as they are returned from executing this operation."
 294                                 },
 295                                 "callbacks": {
 296                                         "$ref": "#/definitions/callbacks",
 297                                         "description": "The list of possible callbacks as they are returned from executing this operation."
 298                                 },
 299                                 "deprecated": {
 300                                         "type": "boolean",
 301                                         "description": "Declares this operation to be deprecated. Consumers SHOULD refrain from usage of the declared operation. Default value is false."
 302                                 },
 303                                 "security": {
 304                                         "type": "array",
 305                                         "items": {
 306                                                 "$ref": "#/definitions/securityRequirement"
 307                                         }
 308                                 },
 309                                 "servers": {
 310                                         "$ref": "#/definitions/server"
 311                                 }
 312                         },
 313                         "patternProperties": {
 314                                 "^X-": {
 315                                         "$ref": "#/definitions/vendorExtension"
 316                                 }
 317                         },
 318                         "additionalProperties": false
 319                 },
 320                 "parameter": {
 321                         "type": "object",
 322                         "description": "Describes a single operation parameter.",
 323                         "required": [ "name", "in" ],
 324                         "properties": {
 325                                 "name": {
 326                                         "type": "string",
 327                                         "description": ""
 328                                 },
 329                                 "in": {
 330                                         "type": "string",
 331                                         "enum": [ "query", "header", "path", "cookie" ],
 332                                         "description": "The location of the parameter."
 333                                 },
 334                                 "description": {
 335                                         "type": "string",
 336                                         "description": "A brief description of the parameter. This could contain examples of use. CommonMark syntax can be used for rich text representation."
 337                                 },
 338                                 "required": {
 339                                         "type": "boolean",
 340                                         "description": "Determines whether this parameter is mandatory. If the parameter location is \"path\", this property is required and its value MUST be true. Otherwise, the property MAY be included and its default value is false.",
 341                                         "default": "false"
 342                                 },
 343                                 "deprecated": {
 344                                         "type": "boolean",
 345                                         "description": "Specifies that a parameter is deprecated and SHOULD be transitioned out of usage."
 346                                 },
 347                                 "allowEmptyValue": {
 348                                         "type": "boolean",
 349                                         "description": "Sets the ability to pass empty-valued parameters. This is valid only for query parameters and allows sending a parameter with an empty value. Default value is false. If style is used, if behavior is n/a, the value of allowEmptyValue SHALL be ignored."
 350                                 },
 351                                 "schema": {
 352                                         "anyOf": [
 353                                                 { "$ref": "#/definitions/schema" },
 354                                                 { "$ref": "#/definitions/reference" }
 355                                         ]
 356                                 }
 357                         },
 358                         "patternProperties": {
 359                                 "^X-": {
 360                                         "$ref": "#/definitions/vendorExtension"
 361                                 }
 362                         },
 363                         "additionalProperties": false
 364                 },
 365                 "reference": {
 366                         "type": "object",
 367                         "description": "A simple object to allow referencing other components in the specification, internally and externally",
 368                         "required": [ "$ref" ],
 369                         "properties": {
 370                                 "$ref": {
 371                                         "type": "string",
 372                                         "description": "The reference string"
 373                                 }
 374                         }
 375                 },
 376                 "responses": {
 377                         "type": "object",
 378                         "description": "A container for the expected responses of an operation. The container maps a HTTP response code to the expected response.",
 379                         "patternProperties": {
 380                                 "^([0-9]{3})$|^(default)$": {
 381                                         "$ref": "#/definitions/responseValue"
 382                                 },
 383                                 "^X-": {
 384                                         "$ref": "#/definitions/vendorExtension"
 385                                 }
 386                         },
 387                         "additionalProperties": false
 388                 },
 389                 "responseValue": {
 390                         "oneOf": [
 391                                 {
 392                                         "$ref": "#/definitions/response"
 393                                 },
 394                                 {
 395                                         "$ref": "#/definitions/reference"
 396                                 }
 397                         ]
 398                 },
 399                 "response": {
 400                         "type": "object",
 401                         "description": "Describes a single response from an API Operation, including design-time, static links to operations based on the response.",
 402                         "required": [ "description" ],
 403                         "properties": {
 404                                 "description": {
 405                                         "type": "string",
 406                                         "description": "A short description of the response. CommonMark syntax can be used for rich text representation."
 407                                 },
 408                                 "headers": {
 409                                         "$ref": "#/definitions/headers"
 410                                 },
 411                                 "content": {
 412                                         "$ref": "#/definitions/content"
 413                                 },
 414                                 "links": {
 415                                         "$ref": "#/definitions/links"
 416                                 }
 417                         },
 418                         "patternProperties": {
 419                                 "^X-": {
 420                                         "$ref": "#/definitions/vendorExtension"
 421                                 }
 422                         },
 423                         "additionalProperties": false
 424                 },
 425                 "requestBody": {
 426                         "type": "object",
 427                         "required": [ "content" ],
 428                         "properties": {
 429                                 "description": {
 430                                         "type": "string",
 431                                         "description": "A brief description of the request body. This could contain examples of use. CommonMark syntax can be used for rich text representation."
 432                                 },
 433                                 "content": {
 434                                         "$ref": "#/definitions/content",
 435                                         "description": "The content of the request body."
 436                                 },
 437                                 "required": {
 438                                         "type": "boolean",
 439                                         "description": "Determines if the request body is required in the request. Defaults to false.",
 440                                         "default": "false"
 441                                 }
 442                         },
 443                         "patternProperties": {
 444                                 "^X-": {
 445                                         "$ref": "#/definitions/vendorExtension"
 446                                 }
 447                         },
 448                         "additionalProperties": false
 449                 },
 450                 "callbacks": {
 451                         "type": "object",
 452                         "description": "A map of possible out-of band callbacks related to the parent operation. Each value in the map is a Callback Object that describes a request that may be initiated by the API provider and the expected responses. The key value used to identify the callback object is an expression, evaluated at runtime, that identifies a URL to use for the callback operation.",
 453                         "patternProperties": {
 454                                 ".*": {
 455                                         "anyOf": [
 456                                                 { "$ref": "#/definitions/callback" },
 457                                                 { "$ref": "#/definitions/reference" }
 458                                         ]
 459                                 },
 460                                 "^X-": {
 461                                         "$ref": "#/definitions/vendorExtension"
 462                                 }
 463                         },
 464                         "additionalProperties": false
 465                 },
 466                 "callback": {
 467                         "type": "object",
 468                         "description": "A map of possible out-of band callbacks related to the parent operation. Each value in the map is a Path Item Object that describes a set of requests that may be initiated by the API provider and the expected responses. The key value used to identify the callback object is an expression, evaluated at runtime, that identifies a URL to use for the callback operation.",
 469                         "patternProperties": {
 470                                 ".*": {
 471                                         "$ref": "#/definitions/pathItem"
 472                                 },
 473                                 "^X-": {
 474                                         "$ref": "#/definitions/vendorExtension"
 475                                 }
 476                         },
 477                         "additionalProperties": false
 478                 },
 479                 "headers": {
 480                         "type": "object",
 481                         "patternProperties": {
 482                                 ".*": {
 483                                         "anyOf": [
 484                                                 { "$ref": "#/definitions/header" },
 485                                                 { "$ref": "#/definitions/reference" }
 486                                         ]
 487                                 }
 488                         },
 489                         "additionalProperties": false
 490                 },
 491                 "header": {
 492                         "type": "object",
 493                         "properties": {
 494                                 "description": {
 495                                         "type": "string",
 496                                         "description": "A brief description of the parameter. This could contain examples of use. CommonMark syntax can be used for rich text representation."
 497                                 },
 498                                 "required": {
 499                                         "type": "boolean",
 500                                         "description": "Determines whether this parameter is mandatory. If the parameter location is \"path\", this property is required and its value MUST be true. Otherwise, the property MAY be included and its default value is false.",
 501                                         "default": "false"
 502                                 },
 503                                 "deprecated": {
 504                                         "type": "boolean",
 505                                         "description": "Specifies that a parameter is deprecated and SHOULD be transitioned out of usage."
 506                                 },
 507                                 "allowEmptyValue": {
 508                                         "type": "boolean",
 509                                         "description": "Sets the ability to pass empty-valued parameters. This is valid only for query parameters and allows sending a parameter with an empty value. Default value is false. If style is used, if behavior is n/a, the value of allowEmptyValue SHALL be ignored."
 510                                 }
 511                         },
 512                         "patternProperties": {
 513                                 "^X-": {
 514                                         "$ref": "#/definitions/vendorExtension"
 515                                 }
 516                         },
 517                         "additionalProperties": false
 518                 },
 519                 "components": {
 520                         "type": "object",
 521                         "description": "Holds a set of reusable objects for different aspects of the OAS. All objects defined within the components object will have no effect on the API unless they are explicitly referenced from properties outside the components object.",
 522                         "patternProperties": {
 523                                 "^[a-zA-Z0-9.\\-_]+$": {
 524                                         "oneOf": [
 525                                                 { "$ref": "#/definitions/definitions" },
 526                                                 { "$ref": "#/definitions/responsesDefinitions" },
 527                                                 { "$ref": "#/definitions/parametersDefinitions" },
 528                                                 { "$ref": "#/definitions/requestBodyDefinitions" },
 529                                                 { "$ref": "#/definitions/responseHeadersDefinitions" },
 530                                                 { "$ref": "#/definitions/securityDefinitions" },
 531                                                 { "$ref": "#/definitions/linkDefinitions" },
 532                                                 { "$ref": "#/definitions/callbackDefinitions" }
 533                                         ]
 534                                 }
 535                         },
 536                         "additionalProperties": false
 537                 },
 538                 "securityRequirement": {},
 539                 "tag": {
 540                         "type": "object",
 541                         "description": "Allows adding meta data to a single tag that is used by the Operation Object. It is not mandatory to have a Tag Object per tag used there.",
 542                         "required": [ "name" ],
 543                         "additionalProperties": false,
 544                         "patternProperties": {
 545                                 "^X-": {
 546                                         "$ref": "#/definitions/vendorExtension"
 547                                 }
 548                         },
 549                         "properties": {
 550                                 "name": {
 551                                         "type": "string",
 552                                         "description": "The name of the tag."
 553                                 },
 554                                 "description": {
 555                                         "type": "string",
 556                                         "description": "A short description for the tag. CommonMark syntax can be used for rich text representation."
 557                                 },
 558                                 "externalDocs": {
 559                                         "$ref": "#/definitions/externalDocs"
 560                                 }
 561                         }
 562                 },
 563                 "externalDocs": {
 564                         "type": "object",
 565                         "description": "Allows referencing an external resource for extended documentation.",
 566                         "required": [ "url" ],
 567                         "additionalProperties": false,
 568                         "patternProperties": {
 569                                 "^X-": {
 570                                         "$ref": "#/definitions/vendorExtension"
 571                                 }
 572                         },
 573                         "properties": {
 574                                 "description": {
 575                                         "type": "string",
 576                                         "description": "A short description of the target documentation. CommonMark syntax can be used for rich text representation."
 577                                 },
 578                                 "url": {
 579                                         "type": "string",
 580                                         "description": "The URL for the target documentation. Value MUST be in the format of a URL."
 581                                 }
 582                         }
 583                 },
 584                 "serverVariables": {
 585                         "type": "object",
 586                         "description": "",
 587                         "patternProperties": {
 588                                 "^X-": {
 589                                         "$ref": "#/definitions/vendorExtension"
 590                                 },
 591                                 "": {
 592                                         "$ref": "#/definitions/serverVariable"
 593                                 }
 594                         },
 595                         "additionalProperties": false
 596                 },
 597                 "serverVariable": {
 598                         "type": "object",
 599                         "description": "An object representing a Host URL template",
 600                         "additionalProperties": false,
 601                         "required": [ "default" ],
 602                         "properties": {
 603                                 "enums": {
 604                                         "description": "An enumeration of primitive type values to be used if the substitution options are from a limited set.",
 605                                         "type": "string"
 606                                 },
 607                                 "default": {
 608                                         "description": "The default value to use for substitution if an alternate value is not specified, and will be sent if an alternative value is not supplied.",
 609                                         "type": "string"
 610                                 },
 611                                 "description": {
 612                                         "type": "string",
 613                                         "description": "An optional description for the template parameter."
 614                                 }
 615                         }
 616                 },
 617                 "content": {
 618                         "type": "object",
 619                         "description": "Describes a set of supported media types. A Content Object can be used in Request Body Object, Parameter Objects, Header Objects, and Response Objects.",
 620                         "patternProperties": {
 621                                 ".*": {
 622
 623                                 }
 624                         }
 625                 },
 626                 "definitions": {
 627                         "type": "object",
 628                         "additionalProperties": {
 629                                 "$ref": "#/definitions/schema"
 630                         },
 631                         "description": "An object to hold schemas for data types that can be consumed and produced by operations. These data types can be primitives, arrays or models."
 632                 },
 633                 "schema": {
 634                         "type": "object",
 635                         "description": "A deterministic version of a JSON Schema object.",
 636                         "patternProperties": {
 637                                 "^x-": {
 638                                         "$ref": "#/definitions/vendorExtension"
 639                                 }
 640                         },
 641                         "properties": {
 642                                 "$ref": {
 643                                         "type": "string"
 644                                 },
 645                                 "format": {
 646                                         "type": "string"
 647                                 },
 648                                 "title": {
 649                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/title"
 650                                 },
 651                                 "description": {
 652                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/description"
 653                                 },
 654                                 "default": {
 655                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/default"
 656                                 },
 657                                 "multipleOf": {
 658                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/multipleOf"
 659                                 },
 660                                 "maximum": {
 661                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/maximum"
 662                                 },
 663                                 "exclusiveMaximum": {
 664                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMaximum"
 665                                 },
 666                                 "minimum": {
 667                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/minimum"
 668                                 },
 669                                 "exclusiveMinimum": {
 670                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMinimum"
 671                                 },
 672                                 "maxLength": {
 673                                         "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
 674                                 },
 675                                 "minLength": {
 676                                         "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
 677                                 },
 678                                 "pattern": {
 679                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/pattern"
 680                                 },
 681                                 "maxItems": {
 682                                         "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
 683                                 },
 684                                 "minItems": {
 685                                         "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
 686                                 },
 687                                 "uniqueItems": {
 688                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/uniqueItems"
 689                                 },
 690                                 "maxProperties": {
 691                                         "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
 692                                 },
 693                                 "minProperties": {
 694                                         "$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
 695                                 },
 696                                 "required": {
 697                                         "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray"
 698                                 },
 699                                 "enum": {
 700                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/enum"
 701                                 },
 702                                 "additionalProperties": {
 703                                         "anyOf": [
 704                                                 {
 705                                                         "$ref": "#/definitions/schema"
 706                                                 },
 707                                                 {
 708                                                         "type": "boolean"
 709                                                 }
 710                                         ],
 711                                         "default": {}
 712                                 },
 713                                 "type": {
 714                                         "$ref": "http://json-schema.org/draft-04/schema#/properties/type"
 715                                 },
 716                                 "items": {
 717                                         "anyOf": [
 718                                                 {
 719                                                         "$ref": "#/definitions/schema"
 720                                                 },
 721                                                 {
 722                                                         "type": "array",
 723                                                         "minItems": 1,
 724                                                         "items": {
 725                                                                 "$ref": "#/definitions/schema"
 726                                                         }
 727                                                 }
 728                                         ],
 729                                         "default": {}
 730                                 },
 731                                 "allOf": {
 732                                         "type": "array",
 733                                         "minItems": 1,
 734                                         "items": {
 735                                                 "$ref": "#/definitions/schema"
 736                                         }
 737                                 },
 738                                 "properties": {
 739                                         "type": "object",
 740                                         "additionalProperties": {
 741                                                 "$ref": "#/definitions/schema"
 742                                         },
 743                                         "default": {}
 744                                 },
 745                                 "discriminator": {
 746                                         "type": "string"
 747                                 },
 748                                 "readOnly": {
 749                                         "type": "boolean",
 750                                         "default": false
 751                                 },
 752                                 "xml": {
 753                                         "$ref": "#/definitions/xml"
 754                                 },
 755                                 "externalDocs": {
 756                                         "$ref": "#/definitions/externalDocs"
 757                                 },
 758                                 "example": {}
 759                         },
 760                         "additionalProperties": false
 761                 }
 762         }
 763 }
 764