scorpio 0.0.4 → 0.1.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/CHANGELOG.md +8 -0
- data/README.md +37 -14
- data/bin/documents_to_yml.rb +26 -0
- data/documents/swagger.io/v2/schema.json +1607 -0
- data/documents/swagger.io/v2/schema.yml +1079 -0
- data/documents/www.googleapis.com/discovery/v1/apis/discovery/v1/rest +684 -0
- data/{getRest.yml → documents/www.googleapis.com/discovery/v1/apis/discovery/v1/rest.yml} +34 -72
- data/lib/scorpio.rb +30 -1
- data/lib/scorpio/google_api_document.rb +232 -0
- data/lib/scorpio/json-schema-fragments.rb +191 -0
- data/lib/scorpio/json.rb +5 -0
- data/lib/scorpio/json/node.rb +214 -0
- data/lib/scorpio/model.rb +178 -91
- data/lib/scorpio/openapi.rb +81 -0
- data/lib/scorpio/schema.rb +133 -0
- data/lib/scorpio/schema_object_base.rb +227 -0
- data/lib/scorpio/typelike_modules.rb +52 -0
- data/lib/scorpio/version.rb +1 -1
- data/scorpio.gemspec +2 -1
- metadata +20 -8
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA1:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 71c5dc59455a36015512d141156a3fde31869546
|
|
4
|
+
data.tar.gz: 0bce95f243957bd15832951224417510d7925f9b
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: 1c26985aac4d77d19bb97010ada163f50d5107710e20ffc076d8379bd6999d34e3de8b0c0782af5fe481b7faa847203424a4ad0ebc6c133844ee5cc1fcd712d1
|
|
7
|
+
data.tar.gz: 233edb5d4346b6cef88e0502aef2398850c657deb22055c6c142aaf6f5797608d79470e64e3ea140177220a7cf58001a725f15880cf8accff3dbfc3ae59d0d3a
|
data/CHANGELOG.md
CHANGED
|
@@ -1,3 +1,11 @@
|
|
|
1
|
+
# v0.1.0
|
|
2
|
+
|
|
3
|
+
- Rewrite Model, use OpenAPI
|
|
4
|
+
- abstraction for a schema, Scorpio::Schema
|
|
5
|
+
- abstraction for a json node at a path within its document, Scorpio::JSON::Node
|
|
6
|
+
- abstraction for an object represented by a schema, Scorpio::SchemaObjectBase
|
|
7
|
+
- so much more
|
|
8
|
+
|
|
1
9
|
# v0.0.2
|
|
2
10
|
|
|
3
11
|
- Scorpio::Model minor bugfixes and refactoring
|
data/README.md
CHANGED
|
@@ -1,21 +1,25 @@
|
|
|
1
1
|
# Scorpio
|
|
2
2
|
|
|
3
|
-
Scorpio is a library intended to make use of
|
|
3
|
+
Scorpio is a library intended to make use of an OpenAPI document describing a service you are consuming or implementing, for various purposes.
|
|
4
4
|
|
|
5
|
-
|
|
5
|
+
## Background
|
|
6
6
|
|
|
7
|
-
|
|
8
|
-
|
|
7
|
+
To start with, you need an OpenAPI v2 (formerly known as Swagger) document describing a service. v3 support is planned. This document can be written by hand or sometimes generated from other existing sources. The creation of an OpenAPI document specifying your service is outside the scope of Scorpio. Here are several resources on OpenAPI:
|
|
8
|
+
|
|
9
|
+
- [OpenAPI Specification at Wikipedia](https://en.wikipedia.org/wiki/OpenAPI_Specification)
|
|
10
|
+
- [OpenAPI Initiative](https://www.openapis.org/) is the official web site for OpenAPI
|
|
11
|
+
- [OpenAPI Specification on GitHub](https://github.com/OAI/OpenAPI-Specification)
|
|
12
|
+
- [swagger.io](https://swagger.io/) API tooling
|
|
9
13
|
|
|
10
|
-
|
|
14
|
+
OpenAPI relies on the definition of schemas using the JSON schema specification, which can be learned about at http://json-schema.org/
|
|
11
15
|
|
|
12
16
|
## Scorpio::Model
|
|
13
17
|
|
|
14
|
-
Scorpio::Model aims to represent RESTful resources in ruby classes with as little code as possible, given a service with a properly constructed API
|
|
18
|
+
Scorpio::Model aims to represent RESTful resources in ruby classes with as little code as possible, given a service with a properly constructed API specification.
|
|
15
19
|
|
|
16
20
|
A model representing a resource needs to be configured, minimally, with:
|
|
17
21
|
|
|
18
|
-
- the
|
|
22
|
+
- the OpenAPI specification for the REST API
|
|
19
23
|
- the base URL where the service is deployed, relative to which are the paths of the API description
|
|
20
24
|
- the schema(s) the model represents
|
|
21
25
|
|
|
@@ -25,16 +29,16 @@ If the resource has HTTP methods associated with it (most, but not all resources
|
|
|
25
29
|
|
|
26
30
|
When these are set, Scorpio::Model looks through the API description and dynamically sets up methods for the model:
|
|
27
31
|
|
|
28
|
-
- accessors for properties of the model defined as properties of schemas representing the resource in the
|
|
32
|
+
- accessors for properties of the model defined as properties of schemas representing the resource in the specification
|
|
29
33
|
- API method calls on the model class and, where appropriate, on the model instance
|
|
30
34
|
|
|
31
35
|
### Example: Blog
|
|
32
36
|
|
|
33
|
-
Scorpio's tests are a good place to read example code of an API
|
|
37
|
+
Scorpio's tests are a good place to read example code of an API that a client interacts with using Scorpio::Model.
|
|
34
38
|
|
|
35
39
|
The Blog service is defined in test/blog.rb. It uses ActiveRecord models and Sinatra to make a simple RESTful service.
|
|
36
40
|
|
|
37
|
-
Its API is described in `test/
|
|
41
|
+
Its API is described in `test/blog.openapi.yml`, defining the Article resource, several methods (some of which are instance methods), and schemas.
|
|
38
42
|
|
|
39
43
|
The client is set up in `test/blog_scorpio_models.rb`. The base class BlogModel defines the base_url and the api description, as well as some other optional setup done for testing.
|
|
40
44
|
|
|
@@ -48,12 +52,32 @@ Based on those, Article gets the methods of the API description which are tested
|
|
|
48
52
|
|
|
49
53
|
Scorpio provides a pickle adapter to use models with [Pickle](https://rubygems.org/gems/pickle). `require 'scorpio/pickle_adapter'`, ensure that the pickle ORM adapter is enabled, and you should be able to create models as normal with pickle.
|
|
50
54
|
|
|
55
|
+
### Google API discovery service
|
|
56
|
+
|
|
57
|
+
An initial implementation of Scorpio::Model was based on the format defined for Google's API discovery service.
|
|
58
|
+
|
|
59
|
+
For background on the Google discovery service and the API description format it defines, see:
|
|
60
|
+
|
|
61
|
+
- https://developers.google.com/discovery/
|
|
62
|
+
- https://developers.google.com/discovery/v1/reference/
|
|
63
|
+
|
|
64
|
+
This format is still supported indirectly, by converting from a Google API document to OpenAPI using `Scorpio::Google::RestDescription#to_openapi_document`. Example conversion looks like:
|
|
65
|
+
|
|
66
|
+
```ruby
|
|
67
|
+
class MyModel < Scorpio::Model
|
|
68
|
+
rest_description_doc = YAML.load_file('path/to/doc.yml')
|
|
69
|
+
rest_description = Scorpio::Google::RestDescription.new(rest_description_doc)
|
|
70
|
+
set_openapi_document(rest_description.to_openapi_document)
|
|
71
|
+
|
|
72
|
+
# ... the remainder of your setup and model code here
|
|
73
|
+
end
|
|
74
|
+
```
|
|
75
|
+
|
|
51
76
|
## Other
|
|
52
77
|
|
|
53
|
-
The detailed, machine-interpretable description of an API provided by a properly-constructed
|
|
78
|
+
The detailed, machine-interpretable description of an API provided by a properly-constructed OpenAPI specification opens up numerous possibilities to automate aspects of clients and services to an API. These are planned to be implemented in Scorpio:
|
|
54
79
|
|
|
55
|
-
-
|
|
56
|
-
- constructing test objects in a manner similar to FactoryGirl, allowing you to write tests that depend on a service without having to interact with an actual running instance of that service to run your tests
|
|
80
|
+
- constructing test objects in a manner similar to FactoryBot, allowing you to write tests that depend on a service without having to interact with an actual running instance of that service to run your tests
|
|
57
81
|
- rack middleware to test that outgoing HTTP responses are conformant to their response schemas
|
|
58
82
|
- rack middleware to test that incoming HTTP requests are conformant to their request schemas, and that the service handles bad requests appropriately (e.g. ensuring that for any bad request, the service responds with a 4xx error instead of 2xx).
|
|
59
83
|
- integrating with ORMs to generate HTTP responses that are conformant to the response schema corresponding to the resource corresponding to the ORM model
|
|
@@ -62,4 +86,3 @@ The detailed, machine-interpretable description of an API provided by a properly
|
|
|
62
86
|
## License
|
|
63
87
|
|
|
64
88
|
The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
|
|
65
|
-
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
#!/usr/bin/env ruby
|
|
2
|
+
|
|
3
|
+
require 'pathname'
|
|
4
|
+
require 'json'
|
|
5
|
+
require 'yaml'
|
|
6
|
+
Pathname.glob('documents/**/*').select { |p| p.file? && !['.yml', '.yaml'].include?(p.extname) }.each do |file|
|
|
7
|
+
begin
|
|
8
|
+
json_contents = JSON.parse(file.read)
|
|
9
|
+
yaml = YAML.dump(json_contents, line_width: -1)
|
|
10
|
+
yaml_filepath = Pathname.new(file.to_path.chomp('.json') + '.yml')
|
|
11
|
+
if yaml_filepath.exist?
|
|
12
|
+
contents = yaml_filepath.read
|
|
13
|
+
if contents == yaml
|
|
14
|
+
puts "#{yaml_filepath.to_path} unchanged"
|
|
15
|
+
else
|
|
16
|
+
yaml_filepath.write(yaml)
|
|
17
|
+
puts "#{yaml_filepath.to_path} changed; updated"
|
|
18
|
+
end
|
|
19
|
+
else
|
|
20
|
+
yaml_filepath.write(yaml)
|
|
21
|
+
puts "#{yaml_filepath.to_path} created"
|
|
22
|
+
end
|
|
23
|
+
rescue JSON::ParserError
|
|
24
|
+
puts "#{file.to_path}: not json"
|
|
25
|
+
end
|
|
26
|
+
end
|
|
@@ -0,0 +1,1607 @@
|
|
|
1
|
+
{
|
|
2
|
+
"title": "A JSON Schema for Swagger 2.0 API.",
|
|
3
|
+
"id": "http://swagger.io/v2/schema.json#",
|
|
4
|
+
"$schema": "http://json-schema.org/draft-04/schema#",
|
|
5
|
+
"type": "object",
|
|
6
|
+
"required": [
|
|
7
|
+
"swagger",
|
|
8
|
+
"info",
|
|
9
|
+
"paths"
|
|
10
|
+
],
|
|
11
|
+
"additionalProperties": false,
|
|
12
|
+
"patternProperties": {
|
|
13
|
+
"^x-": {
|
|
14
|
+
"$ref": "#/definitions/vendorExtension"
|
|
15
|
+
}
|
|
16
|
+
},
|
|
17
|
+
"properties": {
|
|
18
|
+
"swagger": {
|
|
19
|
+
"type": "string",
|
|
20
|
+
"enum": [
|
|
21
|
+
"2.0"
|
|
22
|
+
],
|
|
23
|
+
"description": "The Swagger version of this document."
|
|
24
|
+
},
|
|
25
|
+
"info": {
|
|
26
|
+
"$ref": "#/definitions/info"
|
|
27
|
+
},
|
|
28
|
+
"host": {
|
|
29
|
+
"type": "string",
|
|
30
|
+
"pattern": "^[^{}/ :\\\\]+(?::\\d+)?$",
|
|
31
|
+
"description": "The host (name or ip) of the API. Example: 'swagger.io'"
|
|
32
|
+
},
|
|
33
|
+
"basePath": {
|
|
34
|
+
"type": "string",
|
|
35
|
+
"pattern": "^/",
|
|
36
|
+
"description": "The base path to the API. Example: '/api'."
|
|
37
|
+
},
|
|
38
|
+
"schemes": {
|
|
39
|
+
"$ref": "#/definitions/schemesList"
|
|
40
|
+
},
|
|
41
|
+
"consumes": {
|
|
42
|
+
"description": "A list of MIME types accepted by the API.",
|
|
43
|
+
"allOf": [
|
|
44
|
+
{
|
|
45
|
+
"$ref": "#/definitions/mediaTypeList"
|
|
46
|
+
}
|
|
47
|
+
]
|
|
48
|
+
},
|
|
49
|
+
"produces": {
|
|
50
|
+
"description": "A list of MIME types the API can produce.",
|
|
51
|
+
"allOf": [
|
|
52
|
+
{
|
|
53
|
+
"$ref": "#/definitions/mediaTypeList"
|
|
54
|
+
}
|
|
55
|
+
]
|
|
56
|
+
},
|
|
57
|
+
"paths": {
|
|
58
|
+
"$ref": "#/definitions/paths"
|
|
59
|
+
},
|
|
60
|
+
"definitions": {
|
|
61
|
+
"$ref": "#/definitions/definitions"
|
|
62
|
+
},
|
|
63
|
+
"parameters": {
|
|
64
|
+
"$ref": "#/definitions/parameterDefinitions"
|
|
65
|
+
},
|
|
66
|
+
"responses": {
|
|
67
|
+
"$ref": "#/definitions/responseDefinitions"
|
|
68
|
+
},
|
|
69
|
+
"security": {
|
|
70
|
+
"$ref": "#/definitions/security"
|
|
71
|
+
},
|
|
72
|
+
"securityDefinitions": {
|
|
73
|
+
"$ref": "#/definitions/securityDefinitions"
|
|
74
|
+
},
|
|
75
|
+
"tags": {
|
|
76
|
+
"type": "array",
|
|
77
|
+
"items": {
|
|
78
|
+
"$ref": "#/definitions/tag"
|
|
79
|
+
},
|
|
80
|
+
"uniqueItems": true
|
|
81
|
+
},
|
|
82
|
+
"externalDocs": {
|
|
83
|
+
"$ref": "#/definitions/externalDocs"
|
|
84
|
+
}
|
|
85
|
+
},
|
|
86
|
+
"definitions": {
|
|
87
|
+
"info": {
|
|
88
|
+
"type": "object",
|
|
89
|
+
"description": "General information about the API.",
|
|
90
|
+
"required": [
|
|
91
|
+
"version",
|
|
92
|
+
"title"
|
|
93
|
+
],
|
|
94
|
+
"additionalProperties": false,
|
|
95
|
+
"patternProperties": {
|
|
96
|
+
"^x-": {
|
|
97
|
+
"$ref": "#/definitions/vendorExtension"
|
|
98
|
+
}
|
|
99
|
+
},
|
|
100
|
+
"properties": {
|
|
101
|
+
"title": {
|
|
102
|
+
"type": "string",
|
|
103
|
+
"description": "A unique and precise title of the API."
|
|
104
|
+
},
|
|
105
|
+
"version": {
|
|
106
|
+
"type": "string",
|
|
107
|
+
"description": "A semantic version number of the API."
|
|
108
|
+
},
|
|
109
|
+
"description": {
|
|
110
|
+
"type": "string",
|
|
111
|
+
"description": "A longer description of the API. Should be different from the title. GitHub Flavored Markdown is allowed."
|
|
112
|
+
},
|
|
113
|
+
"termsOfService": {
|
|
114
|
+
"type": "string",
|
|
115
|
+
"description": "The terms of service for the API."
|
|
116
|
+
},
|
|
117
|
+
"contact": {
|
|
118
|
+
"$ref": "#/definitions/contact"
|
|
119
|
+
},
|
|
120
|
+
"license": {
|
|
121
|
+
"$ref": "#/definitions/license"
|
|
122
|
+
}
|
|
123
|
+
}
|
|
124
|
+
},
|
|
125
|
+
"contact": {
|
|
126
|
+
"type": "object",
|
|
127
|
+
"description": "Contact information for the owners of the API.",
|
|
128
|
+
"additionalProperties": false,
|
|
129
|
+
"properties": {
|
|
130
|
+
"name": {
|
|
131
|
+
"type": "string",
|
|
132
|
+
"description": "The identifying name of the contact person/organization."
|
|
133
|
+
},
|
|
134
|
+
"url": {
|
|
135
|
+
"type": "string",
|
|
136
|
+
"description": "The URL pointing to the contact information.",
|
|
137
|
+
"format": "uri"
|
|
138
|
+
},
|
|
139
|
+
"email": {
|
|
140
|
+
"type": "string",
|
|
141
|
+
"description": "The email address of the contact person/organization.",
|
|
142
|
+
"format": "email"
|
|
143
|
+
}
|
|
144
|
+
},
|
|
145
|
+
"patternProperties": {
|
|
146
|
+
"^x-": {
|
|
147
|
+
"$ref": "#/definitions/vendorExtension"
|
|
148
|
+
}
|
|
149
|
+
}
|
|
150
|
+
},
|
|
151
|
+
"license": {
|
|
152
|
+
"type": "object",
|
|
153
|
+
"required": [
|
|
154
|
+
"name"
|
|
155
|
+
],
|
|
156
|
+
"additionalProperties": false,
|
|
157
|
+
"properties": {
|
|
158
|
+
"name": {
|
|
159
|
+
"type": "string",
|
|
160
|
+
"description": "The name of the license type. It's encouraged to use an OSI compatible license."
|
|
161
|
+
},
|
|
162
|
+
"url": {
|
|
163
|
+
"type": "string",
|
|
164
|
+
"description": "The URL pointing to the license.",
|
|
165
|
+
"format": "uri"
|
|
166
|
+
}
|
|
167
|
+
},
|
|
168
|
+
"patternProperties": {
|
|
169
|
+
"^x-": {
|
|
170
|
+
"$ref": "#/definitions/vendorExtension"
|
|
171
|
+
}
|
|
172
|
+
}
|
|
173
|
+
},
|
|
174
|
+
"paths": {
|
|
175
|
+
"type": "object",
|
|
176
|
+
"description": "Relative paths to the individual endpoints. They must be relative to the 'basePath'.",
|
|
177
|
+
"patternProperties": {
|
|
178
|
+
"^x-": {
|
|
179
|
+
"$ref": "#/definitions/vendorExtension"
|
|
180
|
+
},
|
|
181
|
+
"^/": {
|
|
182
|
+
"$ref": "#/definitions/pathItem"
|
|
183
|
+
}
|
|
184
|
+
},
|
|
185
|
+
"additionalProperties": false
|
|
186
|
+
},
|
|
187
|
+
"definitions": {
|
|
188
|
+
"type": "object",
|
|
189
|
+
"additionalProperties": {
|
|
190
|
+
"$ref": "#/definitions/schema"
|
|
191
|
+
},
|
|
192
|
+
"description": "One or more JSON objects describing the schemas being consumed and produced by the API."
|
|
193
|
+
},
|
|
194
|
+
"parameterDefinitions": {
|
|
195
|
+
"type": "object",
|
|
196
|
+
"additionalProperties": {
|
|
197
|
+
"$ref": "#/definitions/parameter"
|
|
198
|
+
},
|
|
199
|
+
"description": "One or more JSON representations for parameters"
|
|
200
|
+
},
|
|
201
|
+
"responseDefinitions": {
|
|
202
|
+
"type": "object",
|
|
203
|
+
"additionalProperties": {
|
|
204
|
+
"$ref": "#/definitions/response"
|
|
205
|
+
},
|
|
206
|
+
"description": "One or more JSON representations for parameters"
|
|
207
|
+
},
|
|
208
|
+
"externalDocs": {
|
|
209
|
+
"type": "object",
|
|
210
|
+
"additionalProperties": false,
|
|
211
|
+
"description": "information about external documentation",
|
|
212
|
+
"required": [
|
|
213
|
+
"url"
|
|
214
|
+
],
|
|
215
|
+
"properties": {
|
|
216
|
+
"description": {
|
|
217
|
+
"type": "string"
|
|
218
|
+
},
|
|
219
|
+
"url": {
|
|
220
|
+
"type": "string",
|
|
221
|
+
"format": "uri"
|
|
222
|
+
}
|
|
223
|
+
},
|
|
224
|
+
"patternProperties": {
|
|
225
|
+
"^x-": {
|
|
226
|
+
"$ref": "#/definitions/vendorExtension"
|
|
227
|
+
}
|
|
228
|
+
}
|
|
229
|
+
},
|
|
230
|
+
"examples": {
|
|
231
|
+
"type": "object",
|
|
232
|
+
"additionalProperties": true
|
|
233
|
+
},
|
|
234
|
+
"mimeType": {
|
|
235
|
+
"type": "string",
|
|
236
|
+
"description": "The MIME type of the HTTP message."
|
|
237
|
+
},
|
|
238
|
+
"operation": {
|
|
239
|
+
"type": "object",
|
|
240
|
+
"required": [
|
|
241
|
+
"responses"
|
|
242
|
+
],
|
|
243
|
+
"additionalProperties": false,
|
|
244
|
+
"patternProperties": {
|
|
245
|
+
"^x-": {
|
|
246
|
+
"$ref": "#/definitions/vendorExtension"
|
|
247
|
+
}
|
|
248
|
+
},
|
|
249
|
+
"properties": {
|
|
250
|
+
"tags": {
|
|
251
|
+
"type": "array",
|
|
252
|
+
"items": {
|
|
253
|
+
"type": "string"
|
|
254
|
+
},
|
|
255
|
+
"uniqueItems": true
|
|
256
|
+
},
|
|
257
|
+
"summary": {
|
|
258
|
+
"type": "string",
|
|
259
|
+
"description": "A brief summary of the operation."
|
|
260
|
+
},
|
|
261
|
+
"description": {
|
|
262
|
+
"type": "string",
|
|
263
|
+
"description": "A longer description of the operation, GitHub Flavored Markdown is allowed."
|
|
264
|
+
},
|
|
265
|
+
"externalDocs": {
|
|
266
|
+
"$ref": "#/definitions/externalDocs"
|
|
267
|
+
},
|
|
268
|
+
"operationId": {
|
|
269
|
+
"type": "string",
|
|
270
|
+
"description": "A unique identifier of the operation."
|
|
271
|
+
},
|
|
272
|
+
"produces": {
|
|
273
|
+
"description": "A list of MIME types the API can produce.",
|
|
274
|
+
"allOf": [
|
|
275
|
+
{
|
|
276
|
+
"$ref": "#/definitions/mediaTypeList"
|
|
277
|
+
}
|
|
278
|
+
]
|
|
279
|
+
},
|
|
280
|
+
"consumes": {
|
|
281
|
+
"description": "A list of MIME types the API can consume.",
|
|
282
|
+
"allOf": [
|
|
283
|
+
{
|
|
284
|
+
"$ref": "#/definitions/mediaTypeList"
|
|
285
|
+
}
|
|
286
|
+
]
|
|
287
|
+
},
|
|
288
|
+
"parameters": {
|
|
289
|
+
"$ref": "#/definitions/parametersList"
|
|
290
|
+
},
|
|
291
|
+
"responses": {
|
|
292
|
+
"$ref": "#/definitions/responses"
|
|
293
|
+
},
|
|
294
|
+
"schemes": {
|
|
295
|
+
"$ref": "#/definitions/schemesList"
|
|
296
|
+
},
|
|
297
|
+
"deprecated": {
|
|
298
|
+
"type": "boolean",
|
|
299
|
+
"default": false
|
|
300
|
+
},
|
|
301
|
+
"security": {
|
|
302
|
+
"$ref": "#/definitions/security"
|
|
303
|
+
}
|
|
304
|
+
}
|
|
305
|
+
},
|
|
306
|
+
"pathItem": {
|
|
307
|
+
"type": "object",
|
|
308
|
+
"additionalProperties": false,
|
|
309
|
+
"patternProperties": {
|
|
310
|
+
"^x-": {
|
|
311
|
+
"$ref": "#/definitions/vendorExtension"
|
|
312
|
+
}
|
|
313
|
+
},
|
|
314
|
+
"properties": {
|
|
315
|
+
"$ref": {
|
|
316
|
+
"type": "string"
|
|
317
|
+
},
|
|
318
|
+
"get": {
|
|
319
|
+
"$ref": "#/definitions/operation"
|
|
320
|
+
},
|
|
321
|
+
"put": {
|
|
322
|
+
"$ref": "#/definitions/operation"
|
|
323
|
+
},
|
|
324
|
+
"post": {
|
|
325
|
+
"$ref": "#/definitions/operation"
|
|
326
|
+
},
|
|
327
|
+
"delete": {
|
|
328
|
+
"$ref": "#/definitions/operation"
|
|
329
|
+
},
|
|
330
|
+
"options": {
|
|
331
|
+
"$ref": "#/definitions/operation"
|
|
332
|
+
},
|
|
333
|
+
"head": {
|
|
334
|
+
"$ref": "#/definitions/operation"
|
|
335
|
+
},
|
|
336
|
+
"patch": {
|
|
337
|
+
"$ref": "#/definitions/operation"
|
|
338
|
+
},
|
|
339
|
+
"parameters": {
|
|
340
|
+
"$ref": "#/definitions/parametersList"
|
|
341
|
+
}
|
|
342
|
+
}
|
|
343
|
+
},
|
|
344
|
+
"responses": {
|
|
345
|
+
"type": "object",
|
|
346
|
+
"description": "Response objects names can either be any valid HTTP status code or 'default'.",
|
|
347
|
+
"minProperties": 1,
|
|
348
|
+
"additionalProperties": false,
|
|
349
|
+
"patternProperties": {
|
|
350
|
+
"^([0-9]{3})$|^(default)$": {
|
|
351
|
+
"$ref": "#/definitions/responseValue"
|
|
352
|
+
},
|
|
353
|
+
"^x-": {
|
|
354
|
+
"$ref": "#/definitions/vendorExtension"
|
|
355
|
+
}
|
|
356
|
+
},
|
|
357
|
+
"not": {
|
|
358
|
+
"type": "object",
|
|
359
|
+
"additionalProperties": false,
|
|
360
|
+
"patternProperties": {
|
|
361
|
+
"^x-": {
|
|
362
|
+
"$ref": "#/definitions/vendorExtension"
|
|
363
|
+
}
|
|
364
|
+
}
|
|
365
|
+
}
|
|
366
|
+
},
|
|
367
|
+
"responseValue": {
|
|
368
|
+
"oneOf": [
|
|
369
|
+
{
|
|
370
|
+
"$ref": "#/definitions/response"
|
|
371
|
+
},
|
|
372
|
+
{
|
|
373
|
+
"$ref": "#/definitions/jsonReference"
|
|
374
|
+
}
|
|
375
|
+
]
|
|
376
|
+
},
|
|
377
|
+
"response": {
|
|
378
|
+
"type": "object",
|
|
379
|
+
"required": [
|
|
380
|
+
"description"
|
|
381
|
+
],
|
|
382
|
+
"properties": {
|
|
383
|
+
"description": {
|
|
384
|
+
"type": "string"
|
|
385
|
+
},
|
|
386
|
+
"schema": {
|
|
387
|
+
"oneOf": [
|
|
388
|
+
{
|
|
389
|
+
"$ref": "#/definitions/schema"
|
|
390
|
+
},
|
|
391
|
+
{
|
|
392
|
+
"$ref": "#/definitions/fileSchema"
|
|
393
|
+
}
|
|
394
|
+
]
|
|
395
|
+
},
|
|
396
|
+
"headers": {
|
|
397
|
+
"$ref": "#/definitions/headers"
|
|
398
|
+
},
|
|
399
|
+
"examples": {
|
|
400
|
+
"$ref": "#/definitions/examples"
|
|
401
|
+
}
|
|
402
|
+
},
|
|
403
|
+
"additionalProperties": false,
|
|
404
|
+
"patternProperties": {
|
|
405
|
+
"^x-": {
|
|
406
|
+
"$ref": "#/definitions/vendorExtension"
|
|
407
|
+
}
|
|
408
|
+
}
|
|
409
|
+
},
|
|
410
|
+
"headers": {
|
|
411
|
+
"type": "object",
|
|
412
|
+
"additionalProperties": {
|
|
413
|
+
"$ref": "#/definitions/header"
|
|
414
|
+
}
|
|
415
|
+
},
|
|
416
|
+
"header": {
|
|
417
|
+
"type": "object",
|
|
418
|
+
"additionalProperties": false,
|
|
419
|
+
"required": [
|
|
420
|
+
"type"
|
|
421
|
+
],
|
|
422
|
+
"properties": {
|
|
423
|
+
"type": {
|
|
424
|
+
"type": "string",
|
|
425
|
+
"enum": [
|
|
426
|
+
"string",
|
|
427
|
+
"number",
|
|
428
|
+
"integer",
|
|
429
|
+
"boolean",
|
|
430
|
+
"array"
|
|
431
|
+
]
|
|
432
|
+
},
|
|
433
|
+
"format": {
|
|
434
|
+
"type": "string"
|
|
435
|
+
},
|
|
436
|
+
"items": {
|
|
437
|
+
"$ref": "#/definitions/primitivesItems"
|
|
438
|
+
},
|
|
439
|
+
"collectionFormat": {
|
|
440
|
+
"$ref": "#/definitions/collectionFormat"
|
|
441
|
+
},
|
|
442
|
+
"default": {
|
|
443
|
+
"$ref": "#/definitions/default"
|
|
444
|
+
},
|
|
445
|
+
"maximum": {
|
|
446
|
+
"$ref": "#/definitions/maximum"
|
|
447
|
+
},
|
|
448
|
+
"exclusiveMaximum": {
|
|
449
|
+
"$ref": "#/definitions/exclusiveMaximum"
|
|
450
|
+
},
|
|
451
|
+
"minimum": {
|
|
452
|
+
"$ref": "#/definitions/minimum"
|
|
453
|
+
},
|
|
454
|
+
"exclusiveMinimum": {
|
|
455
|
+
"$ref": "#/definitions/exclusiveMinimum"
|
|
456
|
+
},
|
|
457
|
+
"maxLength": {
|
|
458
|
+
"$ref": "#/definitions/maxLength"
|
|
459
|
+
},
|
|
460
|
+
"minLength": {
|
|
461
|
+
"$ref": "#/definitions/minLength"
|
|
462
|
+
},
|
|
463
|
+
"pattern": {
|
|
464
|
+
"$ref": "#/definitions/pattern"
|
|
465
|
+
},
|
|
466
|
+
"maxItems": {
|
|
467
|
+
"$ref": "#/definitions/maxItems"
|
|
468
|
+
},
|
|
469
|
+
"minItems": {
|
|
470
|
+
"$ref": "#/definitions/minItems"
|
|
471
|
+
},
|
|
472
|
+
"uniqueItems": {
|
|
473
|
+
"$ref": "#/definitions/uniqueItems"
|
|
474
|
+
},
|
|
475
|
+
"enum": {
|
|
476
|
+
"$ref": "#/definitions/enum"
|
|
477
|
+
},
|
|
478
|
+
"multipleOf": {
|
|
479
|
+
"$ref": "#/definitions/multipleOf"
|
|
480
|
+
},
|
|
481
|
+
"description": {
|
|
482
|
+
"type": "string"
|
|
483
|
+
}
|
|
484
|
+
},
|
|
485
|
+
"patternProperties": {
|
|
486
|
+
"^x-": {
|
|
487
|
+
"$ref": "#/definitions/vendorExtension"
|
|
488
|
+
}
|
|
489
|
+
}
|
|
490
|
+
},
|
|
491
|
+
"vendorExtension": {
|
|
492
|
+
"description": "Any property starting with x- is valid.",
|
|
493
|
+
"additionalProperties": true,
|
|
494
|
+
"additionalItems": true
|
|
495
|
+
},
|
|
496
|
+
"bodyParameter": {
|
|
497
|
+
"type": "object",
|
|
498
|
+
"required": [
|
|
499
|
+
"name",
|
|
500
|
+
"in",
|
|
501
|
+
"schema"
|
|
502
|
+
],
|
|
503
|
+
"patternProperties": {
|
|
504
|
+
"^x-": {
|
|
505
|
+
"$ref": "#/definitions/vendorExtension"
|
|
506
|
+
}
|
|
507
|
+
},
|
|
508
|
+
"properties": {
|
|
509
|
+
"description": {
|
|
510
|
+
"type": "string",
|
|
511
|
+
"description": "A brief description of the parameter. This could contain examples of use. GitHub Flavored Markdown is allowed."
|
|
512
|
+
},
|
|
513
|
+
"name": {
|
|
514
|
+
"type": "string",
|
|
515
|
+
"description": "The name of the parameter."
|
|
516
|
+
},
|
|
517
|
+
"in": {
|
|
518
|
+
"type": "string",
|
|
519
|
+
"description": "Determines the location of the parameter.",
|
|
520
|
+
"enum": [
|
|
521
|
+
"body"
|
|
522
|
+
]
|
|
523
|
+
},
|
|
524
|
+
"required": {
|
|
525
|
+
"type": "boolean",
|
|
526
|
+
"description": "Determines whether or not this parameter is required or optional.",
|
|
527
|
+
"default": false
|
|
528
|
+
},
|
|
529
|
+
"schema": {
|
|
530
|
+
"$ref": "#/definitions/schema"
|
|
531
|
+
}
|
|
532
|
+
},
|
|
533
|
+
"additionalProperties": false
|
|
534
|
+
},
|
|
535
|
+
"headerParameterSubSchema": {
|
|
536
|
+
"additionalProperties": false,
|
|
537
|
+
"patternProperties": {
|
|
538
|
+
"^x-": {
|
|
539
|
+
"$ref": "#/definitions/vendorExtension"
|
|
540
|
+
}
|
|
541
|
+
},
|
|
542
|
+
"properties": {
|
|
543
|
+
"required": {
|
|
544
|
+
"type": "boolean",
|
|
545
|
+
"description": "Determines whether or not this parameter is required or optional.",
|
|
546
|
+
"default": false
|
|
547
|
+
},
|
|
548
|
+
"in": {
|
|
549
|
+
"type": "string",
|
|
550
|
+
"description": "Determines the location of the parameter.",
|
|
551
|
+
"enum": [
|
|
552
|
+
"header"
|
|
553
|
+
]
|
|
554
|
+
},
|
|
555
|
+
"description": {
|
|
556
|
+
"type": "string",
|
|
557
|
+
"description": "A brief description of the parameter. This could contain examples of use. GitHub Flavored Markdown is allowed."
|
|
558
|
+
},
|
|
559
|
+
"name": {
|
|
560
|
+
"type": "string",
|
|
561
|
+
"description": "The name of the parameter."
|
|
562
|
+
},
|
|
563
|
+
"type": {
|
|
564
|
+
"type": "string",
|
|
565
|
+
"enum": [
|
|
566
|
+
"string",
|
|
567
|
+
"number",
|
|
568
|
+
"boolean",
|
|
569
|
+
"integer",
|
|
570
|
+
"array"
|
|
571
|
+
]
|
|
572
|
+
},
|
|
573
|
+
"format": {
|
|
574
|
+
"type": "string"
|
|
575
|
+
},
|
|
576
|
+
"items": {
|
|
577
|
+
"$ref": "#/definitions/primitivesItems"
|
|
578
|
+
},
|
|
579
|
+
"collectionFormat": {
|
|
580
|
+
"$ref": "#/definitions/collectionFormat"
|
|
581
|
+
},
|
|
582
|
+
"default": {
|
|
583
|
+
"$ref": "#/definitions/default"
|
|
584
|
+
},
|
|
585
|
+
"maximum": {
|
|
586
|
+
"$ref": "#/definitions/maximum"
|
|
587
|
+
},
|
|
588
|
+
"exclusiveMaximum": {
|
|
589
|
+
"$ref": "#/definitions/exclusiveMaximum"
|
|
590
|
+
},
|
|
591
|
+
"minimum": {
|
|
592
|
+
"$ref": "#/definitions/minimum"
|
|
593
|
+
},
|
|
594
|
+
"exclusiveMinimum": {
|
|
595
|
+
"$ref": "#/definitions/exclusiveMinimum"
|
|
596
|
+
},
|
|
597
|
+
"maxLength": {
|
|
598
|
+
"$ref": "#/definitions/maxLength"
|
|
599
|
+
},
|
|
600
|
+
"minLength": {
|
|
601
|
+
"$ref": "#/definitions/minLength"
|
|
602
|
+
},
|
|
603
|
+
"pattern": {
|
|
604
|
+
"$ref": "#/definitions/pattern"
|
|
605
|
+
},
|
|
606
|
+
"maxItems": {
|
|
607
|
+
"$ref": "#/definitions/maxItems"
|
|
608
|
+
},
|
|
609
|
+
"minItems": {
|
|
610
|
+
"$ref": "#/definitions/minItems"
|
|
611
|
+
},
|
|
612
|
+
"uniqueItems": {
|
|
613
|
+
"$ref": "#/definitions/uniqueItems"
|
|
614
|
+
},
|
|
615
|
+
"enum": {
|
|
616
|
+
"$ref": "#/definitions/enum"
|
|
617
|
+
},
|
|
618
|
+
"multipleOf": {
|
|
619
|
+
"$ref": "#/definitions/multipleOf"
|
|
620
|
+
}
|
|
621
|
+
}
|
|
622
|
+
},
|
|
623
|
+
"queryParameterSubSchema": {
|
|
624
|
+
"additionalProperties": false,
|
|
625
|
+
"patternProperties": {
|
|
626
|
+
"^x-": {
|
|
627
|
+
"$ref": "#/definitions/vendorExtension"
|
|
628
|
+
}
|
|
629
|
+
},
|
|
630
|
+
"properties": {
|
|
631
|
+
"required": {
|
|
632
|
+
"type": "boolean",
|
|
633
|
+
"description": "Determines whether or not this parameter is required or optional.",
|
|
634
|
+
"default": false
|
|
635
|
+
},
|
|
636
|
+
"in": {
|
|
637
|
+
"type": "string",
|
|
638
|
+
"description": "Determines the location of the parameter.",
|
|
639
|
+
"enum": [
|
|
640
|
+
"query"
|
|
641
|
+
]
|
|
642
|
+
},
|
|
643
|
+
"description": {
|
|
644
|
+
"type": "string",
|
|
645
|
+
"description": "A brief description of the parameter. This could contain examples of use. GitHub Flavored Markdown is allowed."
|
|
646
|
+
},
|
|
647
|
+
"name": {
|
|
648
|
+
"type": "string",
|
|
649
|
+
"description": "The name of the parameter."
|
|
650
|
+
},
|
|
651
|
+
"allowEmptyValue": {
|
|
652
|
+
"type": "boolean",
|
|
653
|
+
"default": false,
|
|
654
|
+
"description": "allows sending a parameter by name only or with an empty value."
|
|
655
|
+
},
|
|
656
|
+
"type": {
|
|
657
|
+
"type": "string",
|
|
658
|
+
"enum": [
|
|
659
|
+
"string",
|
|
660
|
+
"number",
|
|
661
|
+
"boolean",
|
|
662
|
+
"integer",
|
|
663
|
+
"array"
|
|
664
|
+
]
|
|
665
|
+
},
|
|
666
|
+
"format": {
|
|
667
|
+
"type": "string"
|
|
668
|
+
},
|
|
669
|
+
"items": {
|
|
670
|
+
"$ref": "#/definitions/primitivesItems"
|
|
671
|
+
},
|
|
672
|
+
"collectionFormat": {
|
|
673
|
+
"$ref": "#/definitions/collectionFormatWithMulti"
|
|
674
|
+
},
|
|
675
|
+
"default": {
|
|
676
|
+
"$ref": "#/definitions/default"
|
|
677
|
+
},
|
|
678
|
+
"maximum": {
|
|
679
|
+
"$ref": "#/definitions/maximum"
|
|
680
|
+
},
|
|
681
|
+
"exclusiveMaximum": {
|
|
682
|
+
"$ref": "#/definitions/exclusiveMaximum"
|
|
683
|
+
},
|
|
684
|
+
"minimum": {
|
|
685
|
+
"$ref": "#/definitions/minimum"
|
|
686
|
+
},
|
|
687
|
+
"exclusiveMinimum": {
|
|
688
|
+
"$ref": "#/definitions/exclusiveMinimum"
|
|
689
|
+
},
|
|
690
|
+
"maxLength": {
|
|
691
|
+
"$ref": "#/definitions/maxLength"
|
|
692
|
+
},
|
|
693
|
+
"minLength": {
|
|
694
|
+
"$ref": "#/definitions/minLength"
|
|
695
|
+
},
|
|
696
|
+
"pattern": {
|
|
697
|
+
"$ref": "#/definitions/pattern"
|
|
698
|
+
},
|
|
699
|
+
"maxItems": {
|
|
700
|
+
"$ref": "#/definitions/maxItems"
|
|
701
|
+
},
|
|
702
|
+
"minItems": {
|
|
703
|
+
"$ref": "#/definitions/minItems"
|
|
704
|
+
},
|
|
705
|
+
"uniqueItems": {
|
|
706
|
+
"$ref": "#/definitions/uniqueItems"
|
|
707
|
+
},
|
|
708
|
+
"enum": {
|
|
709
|
+
"$ref": "#/definitions/enum"
|
|
710
|
+
},
|
|
711
|
+
"multipleOf": {
|
|
712
|
+
"$ref": "#/definitions/multipleOf"
|
|
713
|
+
}
|
|
714
|
+
}
|
|
715
|
+
},
|
|
716
|
+
"formDataParameterSubSchema": {
|
|
717
|
+
"additionalProperties": false,
|
|
718
|
+
"patternProperties": {
|
|
719
|
+
"^x-": {
|
|
720
|
+
"$ref": "#/definitions/vendorExtension"
|
|
721
|
+
}
|
|
722
|
+
},
|
|
723
|
+
"properties": {
|
|
724
|
+
"required": {
|
|
725
|
+
"type": "boolean",
|
|
726
|
+
"description": "Determines whether or not this parameter is required or optional.",
|
|
727
|
+
"default": false
|
|
728
|
+
},
|
|
729
|
+
"in": {
|
|
730
|
+
"type": "string",
|
|
731
|
+
"description": "Determines the location of the parameter.",
|
|
732
|
+
"enum": [
|
|
733
|
+
"formData"
|
|
734
|
+
]
|
|
735
|
+
},
|
|
736
|
+
"description": {
|
|
737
|
+
"type": "string",
|
|
738
|
+
"description": "A brief description of the parameter. This could contain examples of use. GitHub Flavored Markdown is allowed."
|
|
739
|
+
},
|
|
740
|
+
"name": {
|
|
741
|
+
"type": "string",
|
|
742
|
+
"description": "The name of the parameter."
|
|
743
|
+
},
|
|
744
|
+
"allowEmptyValue": {
|
|
745
|
+
"type": "boolean",
|
|
746
|
+
"default": false,
|
|
747
|
+
"description": "allows sending a parameter by name only or with an empty value."
|
|
748
|
+
},
|
|
749
|
+
"type": {
|
|
750
|
+
"type": "string",
|
|
751
|
+
"enum": [
|
|
752
|
+
"string",
|
|
753
|
+
"number",
|
|
754
|
+
"boolean",
|
|
755
|
+
"integer",
|
|
756
|
+
"array",
|
|
757
|
+
"file"
|
|
758
|
+
]
|
|
759
|
+
},
|
|
760
|
+
"format": {
|
|
761
|
+
"type": "string"
|
|
762
|
+
},
|
|
763
|
+
"items": {
|
|
764
|
+
"$ref": "#/definitions/primitivesItems"
|
|
765
|
+
},
|
|
766
|
+
"collectionFormat": {
|
|
767
|
+
"$ref": "#/definitions/collectionFormatWithMulti"
|
|
768
|
+
},
|
|
769
|
+
"default": {
|
|
770
|
+
"$ref": "#/definitions/default"
|
|
771
|
+
},
|
|
772
|
+
"maximum": {
|
|
773
|
+
"$ref": "#/definitions/maximum"
|
|
774
|
+
},
|
|
775
|
+
"exclusiveMaximum": {
|
|
776
|
+
"$ref": "#/definitions/exclusiveMaximum"
|
|
777
|
+
},
|
|
778
|
+
"minimum": {
|
|
779
|
+
"$ref": "#/definitions/minimum"
|
|
780
|
+
},
|
|
781
|
+
"exclusiveMinimum": {
|
|
782
|
+
"$ref": "#/definitions/exclusiveMinimum"
|
|
783
|
+
},
|
|
784
|
+
"maxLength": {
|
|
785
|
+
"$ref": "#/definitions/maxLength"
|
|
786
|
+
},
|
|
787
|
+
"minLength": {
|
|
788
|
+
"$ref": "#/definitions/minLength"
|
|
789
|
+
},
|
|
790
|
+
"pattern": {
|
|
791
|
+
"$ref": "#/definitions/pattern"
|
|
792
|
+
},
|
|
793
|
+
"maxItems": {
|
|
794
|
+
"$ref": "#/definitions/maxItems"
|
|
795
|
+
},
|
|
796
|
+
"minItems": {
|
|
797
|
+
"$ref": "#/definitions/minItems"
|
|
798
|
+
},
|
|
799
|
+
"uniqueItems": {
|
|
800
|
+
"$ref": "#/definitions/uniqueItems"
|
|
801
|
+
},
|
|
802
|
+
"enum": {
|
|
803
|
+
"$ref": "#/definitions/enum"
|
|
804
|
+
},
|
|
805
|
+
"multipleOf": {
|
|
806
|
+
"$ref": "#/definitions/multipleOf"
|
|
807
|
+
}
|
|
808
|
+
}
|
|
809
|
+
},
|
|
810
|
+
"pathParameterSubSchema": {
|
|
811
|
+
"additionalProperties": false,
|
|
812
|
+
"patternProperties": {
|
|
813
|
+
"^x-": {
|
|
814
|
+
"$ref": "#/definitions/vendorExtension"
|
|
815
|
+
}
|
|
816
|
+
},
|
|
817
|
+
"required": [
|
|
818
|
+
"required"
|
|
819
|
+
],
|
|
820
|
+
"properties": {
|
|
821
|
+
"required": {
|
|
822
|
+
"type": "boolean",
|
|
823
|
+
"enum": [
|
|
824
|
+
true
|
|
825
|
+
],
|
|
826
|
+
"description": "Determines whether or not this parameter is required or optional."
|
|
827
|
+
},
|
|
828
|
+
"in": {
|
|
829
|
+
"type": "string",
|
|
830
|
+
"description": "Determines the location of the parameter.",
|
|
831
|
+
"enum": [
|
|
832
|
+
"path"
|
|
833
|
+
]
|
|
834
|
+
},
|
|
835
|
+
"description": {
|
|
836
|
+
"type": "string",
|
|
837
|
+
"description": "A brief description of the parameter. This could contain examples of use. GitHub Flavored Markdown is allowed."
|
|
838
|
+
},
|
|
839
|
+
"name": {
|
|
840
|
+
"type": "string",
|
|
841
|
+
"description": "The name of the parameter."
|
|
842
|
+
},
|
|
843
|
+
"type": {
|
|
844
|
+
"type": "string",
|
|
845
|
+
"enum": [
|
|
846
|
+
"string",
|
|
847
|
+
"number",
|
|
848
|
+
"boolean",
|
|
849
|
+
"integer",
|
|
850
|
+
"array"
|
|
851
|
+
]
|
|
852
|
+
},
|
|
853
|
+
"format": {
|
|
854
|
+
"type": "string"
|
|
855
|
+
},
|
|
856
|
+
"items": {
|
|
857
|
+
"$ref": "#/definitions/primitivesItems"
|
|
858
|
+
},
|
|
859
|
+
"collectionFormat": {
|
|
860
|
+
"$ref": "#/definitions/collectionFormat"
|
|
861
|
+
},
|
|
862
|
+
"default": {
|
|
863
|
+
"$ref": "#/definitions/default"
|
|
864
|
+
},
|
|
865
|
+
"maximum": {
|
|
866
|
+
"$ref": "#/definitions/maximum"
|
|
867
|
+
},
|
|
868
|
+
"exclusiveMaximum": {
|
|
869
|
+
"$ref": "#/definitions/exclusiveMaximum"
|
|
870
|
+
},
|
|
871
|
+
"minimum": {
|
|
872
|
+
"$ref": "#/definitions/minimum"
|
|
873
|
+
},
|
|
874
|
+
"exclusiveMinimum": {
|
|
875
|
+
"$ref": "#/definitions/exclusiveMinimum"
|
|
876
|
+
},
|
|
877
|
+
"maxLength": {
|
|
878
|
+
"$ref": "#/definitions/maxLength"
|
|
879
|
+
},
|
|
880
|
+
"minLength": {
|
|
881
|
+
"$ref": "#/definitions/minLength"
|
|
882
|
+
},
|
|
883
|
+
"pattern": {
|
|
884
|
+
"$ref": "#/definitions/pattern"
|
|
885
|
+
},
|
|
886
|
+
"maxItems": {
|
|
887
|
+
"$ref": "#/definitions/maxItems"
|
|
888
|
+
},
|
|
889
|
+
"minItems": {
|
|
890
|
+
"$ref": "#/definitions/minItems"
|
|
891
|
+
},
|
|
892
|
+
"uniqueItems": {
|
|
893
|
+
"$ref": "#/definitions/uniqueItems"
|
|
894
|
+
},
|
|
895
|
+
"enum": {
|
|
896
|
+
"$ref": "#/definitions/enum"
|
|
897
|
+
},
|
|
898
|
+
"multipleOf": {
|
|
899
|
+
"$ref": "#/definitions/multipleOf"
|
|
900
|
+
}
|
|
901
|
+
}
|
|
902
|
+
},
|
|
903
|
+
"nonBodyParameter": {
|
|
904
|
+
"type": "object",
|
|
905
|
+
"required": [
|
|
906
|
+
"name",
|
|
907
|
+
"in",
|
|
908
|
+
"type"
|
|
909
|
+
],
|
|
910
|
+
"oneOf": [
|
|
911
|
+
{
|
|
912
|
+
"$ref": "#/definitions/headerParameterSubSchema"
|
|
913
|
+
},
|
|
914
|
+
{
|
|
915
|
+
"$ref": "#/definitions/formDataParameterSubSchema"
|
|
916
|
+
},
|
|
917
|
+
{
|
|
918
|
+
"$ref": "#/definitions/queryParameterSubSchema"
|
|
919
|
+
},
|
|
920
|
+
{
|
|
921
|
+
"$ref": "#/definitions/pathParameterSubSchema"
|
|
922
|
+
}
|
|
923
|
+
]
|
|
924
|
+
},
|
|
925
|
+
"parameter": {
|
|
926
|
+
"oneOf": [
|
|
927
|
+
{
|
|
928
|
+
"$ref": "#/definitions/bodyParameter"
|
|
929
|
+
},
|
|
930
|
+
{
|
|
931
|
+
"$ref": "#/definitions/nonBodyParameter"
|
|
932
|
+
}
|
|
933
|
+
]
|
|
934
|
+
},
|
|
935
|
+
"schema": {
|
|
936
|
+
"type": "object",
|
|
937
|
+
"description": "A deterministic version of a JSON Schema object.",
|
|
938
|
+
"patternProperties": {
|
|
939
|
+
"^x-": {
|
|
940
|
+
"$ref": "#/definitions/vendorExtension"
|
|
941
|
+
}
|
|
942
|
+
},
|
|
943
|
+
"properties": {
|
|
944
|
+
"$ref": {
|
|
945
|
+
"type": "string"
|
|
946
|
+
},
|
|
947
|
+
"format": {
|
|
948
|
+
"type": "string"
|
|
949
|
+
},
|
|
950
|
+
"title": {
|
|
951
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/title"
|
|
952
|
+
},
|
|
953
|
+
"description": {
|
|
954
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/description"
|
|
955
|
+
},
|
|
956
|
+
"default": {
|
|
957
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/default"
|
|
958
|
+
},
|
|
959
|
+
"multipleOf": {
|
|
960
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/multipleOf"
|
|
961
|
+
},
|
|
962
|
+
"maximum": {
|
|
963
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/maximum"
|
|
964
|
+
},
|
|
965
|
+
"exclusiveMaximum": {
|
|
966
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMaximum"
|
|
967
|
+
},
|
|
968
|
+
"minimum": {
|
|
969
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/minimum"
|
|
970
|
+
},
|
|
971
|
+
"exclusiveMinimum": {
|
|
972
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMinimum"
|
|
973
|
+
},
|
|
974
|
+
"maxLength": {
|
|
975
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
|
|
976
|
+
},
|
|
977
|
+
"minLength": {
|
|
978
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
|
|
979
|
+
},
|
|
980
|
+
"pattern": {
|
|
981
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/pattern"
|
|
982
|
+
},
|
|
983
|
+
"maxItems": {
|
|
984
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
|
|
985
|
+
},
|
|
986
|
+
"minItems": {
|
|
987
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
|
|
988
|
+
},
|
|
989
|
+
"uniqueItems": {
|
|
990
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/uniqueItems"
|
|
991
|
+
},
|
|
992
|
+
"maxProperties": {
|
|
993
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
|
|
994
|
+
},
|
|
995
|
+
"minProperties": {
|
|
996
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
|
|
997
|
+
},
|
|
998
|
+
"required": {
|
|
999
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray"
|
|
1000
|
+
},
|
|
1001
|
+
"enum": {
|
|
1002
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/enum"
|
|
1003
|
+
},
|
|
1004
|
+
"additionalProperties": {
|
|
1005
|
+
"anyOf": [
|
|
1006
|
+
{
|
|
1007
|
+
"$ref": "#/definitions/schema"
|
|
1008
|
+
},
|
|
1009
|
+
{
|
|
1010
|
+
"type": "boolean"
|
|
1011
|
+
}
|
|
1012
|
+
],
|
|
1013
|
+
"default": {}
|
|
1014
|
+
},
|
|
1015
|
+
"type": {
|
|
1016
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/type"
|
|
1017
|
+
},
|
|
1018
|
+
"items": {
|
|
1019
|
+
"anyOf": [
|
|
1020
|
+
{
|
|
1021
|
+
"$ref": "#/definitions/schema"
|
|
1022
|
+
},
|
|
1023
|
+
{
|
|
1024
|
+
"type": "array",
|
|
1025
|
+
"minItems": 1,
|
|
1026
|
+
"items": {
|
|
1027
|
+
"$ref": "#/definitions/schema"
|
|
1028
|
+
}
|
|
1029
|
+
}
|
|
1030
|
+
],
|
|
1031
|
+
"default": {}
|
|
1032
|
+
},
|
|
1033
|
+
"allOf": {
|
|
1034
|
+
"type": "array",
|
|
1035
|
+
"minItems": 1,
|
|
1036
|
+
"items": {
|
|
1037
|
+
"$ref": "#/definitions/schema"
|
|
1038
|
+
}
|
|
1039
|
+
},
|
|
1040
|
+
"properties": {
|
|
1041
|
+
"type": "object",
|
|
1042
|
+
"additionalProperties": {
|
|
1043
|
+
"$ref": "#/definitions/schema"
|
|
1044
|
+
},
|
|
1045
|
+
"default": {}
|
|
1046
|
+
},
|
|
1047
|
+
"discriminator": {
|
|
1048
|
+
"type": "string"
|
|
1049
|
+
},
|
|
1050
|
+
"readOnly": {
|
|
1051
|
+
"type": "boolean",
|
|
1052
|
+
"default": false
|
|
1053
|
+
},
|
|
1054
|
+
"xml": {
|
|
1055
|
+
"$ref": "#/definitions/xml"
|
|
1056
|
+
},
|
|
1057
|
+
"externalDocs": {
|
|
1058
|
+
"$ref": "#/definitions/externalDocs"
|
|
1059
|
+
},
|
|
1060
|
+
"example": {}
|
|
1061
|
+
},
|
|
1062
|
+
"additionalProperties": false
|
|
1063
|
+
},
|
|
1064
|
+
"fileSchema": {
|
|
1065
|
+
"type": "object",
|
|
1066
|
+
"description": "A deterministic version of a JSON Schema object.",
|
|
1067
|
+
"patternProperties": {
|
|
1068
|
+
"^x-": {
|
|
1069
|
+
"$ref": "#/definitions/vendorExtension"
|
|
1070
|
+
}
|
|
1071
|
+
},
|
|
1072
|
+
"required": [
|
|
1073
|
+
"type"
|
|
1074
|
+
],
|
|
1075
|
+
"properties": {
|
|
1076
|
+
"format": {
|
|
1077
|
+
"type": "string"
|
|
1078
|
+
},
|
|
1079
|
+
"title": {
|
|
1080
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/title"
|
|
1081
|
+
},
|
|
1082
|
+
"description": {
|
|
1083
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/description"
|
|
1084
|
+
},
|
|
1085
|
+
"default": {
|
|
1086
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/default"
|
|
1087
|
+
},
|
|
1088
|
+
"required": {
|
|
1089
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray"
|
|
1090
|
+
},
|
|
1091
|
+
"type": {
|
|
1092
|
+
"type": "string",
|
|
1093
|
+
"enum": [
|
|
1094
|
+
"file"
|
|
1095
|
+
]
|
|
1096
|
+
},
|
|
1097
|
+
"readOnly": {
|
|
1098
|
+
"type": "boolean",
|
|
1099
|
+
"default": false
|
|
1100
|
+
},
|
|
1101
|
+
"externalDocs": {
|
|
1102
|
+
"$ref": "#/definitions/externalDocs"
|
|
1103
|
+
},
|
|
1104
|
+
"example": {}
|
|
1105
|
+
},
|
|
1106
|
+
"additionalProperties": false
|
|
1107
|
+
},
|
|
1108
|
+
"primitivesItems": {
|
|
1109
|
+
"type": "object",
|
|
1110
|
+
"additionalProperties": false,
|
|
1111
|
+
"properties": {
|
|
1112
|
+
"type": {
|
|
1113
|
+
"type": "string",
|
|
1114
|
+
"enum": [
|
|
1115
|
+
"string",
|
|
1116
|
+
"number",
|
|
1117
|
+
"integer",
|
|
1118
|
+
"boolean",
|
|
1119
|
+
"array"
|
|
1120
|
+
]
|
|
1121
|
+
},
|
|
1122
|
+
"format": {
|
|
1123
|
+
"type": "string"
|
|
1124
|
+
},
|
|
1125
|
+
"items": {
|
|
1126
|
+
"$ref": "#/definitions/primitivesItems"
|
|
1127
|
+
},
|
|
1128
|
+
"collectionFormat": {
|
|
1129
|
+
"$ref": "#/definitions/collectionFormat"
|
|
1130
|
+
},
|
|
1131
|
+
"default": {
|
|
1132
|
+
"$ref": "#/definitions/default"
|
|
1133
|
+
},
|
|
1134
|
+
"maximum": {
|
|
1135
|
+
"$ref": "#/definitions/maximum"
|
|
1136
|
+
},
|
|
1137
|
+
"exclusiveMaximum": {
|
|
1138
|
+
"$ref": "#/definitions/exclusiveMaximum"
|
|
1139
|
+
},
|
|
1140
|
+
"minimum": {
|
|
1141
|
+
"$ref": "#/definitions/minimum"
|
|
1142
|
+
},
|
|
1143
|
+
"exclusiveMinimum": {
|
|
1144
|
+
"$ref": "#/definitions/exclusiveMinimum"
|
|
1145
|
+
},
|
|
1146
|
+
"maxLength": {
|
|
1147
|
+
"$ref": "#/definitions/maxLength"
|
|
1148
|
+
},
|
|
1149
|
+
"minLength": {
|
|
1150
|
+
"$ref": "#/definitions/minLength"
|
|
1151
|
+
},
|
|
1152
|
+
"pattern": {
|
|
1153
|
+
"$ref": "#/definitions/pattern"
|
|
1154
|
+
},
|
|
1155
|
+
"maxItems": {
|
|
1156
|
+
"$ref": "#/definitions/maxItems"
|
|
1157
|
+
},
|
|
1158
|
+
"minItems": {
|
|
1159
|
+
"$ref": "#/definitions/minItems"
|
|
1160
|
+
},
|
|
1161
|
+
"uniqueItems": {
|
|
1162
|
+
"$ref": "#/definitions/uniqueItems"
|
|
1163
|
+
},
|
|
1164
|
+
"enum": {
|
|
1165
|
+
"$ref": "#/definitions/enum"
|
|
1166
|
+
},
|
|
1167
|
+
"multipleOf": {
|
|
1168
|
+
"$ref": "#/definitions/multipleOf"
|
|
1169
|
+
}
|
|
1170
|
+
},
|
|
1171
|
+
"patternProperties": {
|
|
1172
|
+
"^x-": {
|
|
1173
|
+
"$ref": "#/definitions/vendorExtension"
|
|
1174
|
+
}
|
|
1175
|
+
}
|
|
1176
|
+
},
|
|
1177
|
+
"security": {
|
|
1178
|
+
"type": "array",
|
|
1179
|
+
"items": {
|
|
1180
|
+
"$ref": "#/definitions/securityRequirement"
|
|
1181
|
+
},
|
|
1182
|
+
"uniqueItems": true
|
|
1183
|
+
},
|
|
1184
|
+
"securityRequirement": {
|
|
1185
|
+
"type": "object",
|
|
1186
|
+
"additionalProperties": {
|
|
1187
|
+
"type": "array",
|
|
1188
|
+
"items": {
|
|
1189
|
+
"type": "string"
|
|
1190
|
+
},
|
|
1191
|
+
"uniqueItems": true
|
|
1192
|
+
}
|
|
1193
|
+
},
|
|
1194
|
+
"xml": {
|
|
1195
|
+
"type": "object",
|
|
1196
|
+
"additionalProperties": false,
|
|
1197
|
+
"properties": {
|
|
1198
|
+
"name": {
|
|
1199
|
+
"type": "string"
|
|
1200
|
+
},
|
|
1201
|
+
"namespace": {
|
|
1202
|
+
"type": "string"
|
|
1203
|
+
},
|
|
1204
|
+
"prefix": {
|
|
1205
|
+
"type": "string"
|
|
1206
|
+
},
|
|
1207
|
+
"attribute": {
|
|
1208
|
+
"type": "boolean",
|
|
1209
|
+
"default": false
|
|
1210
|
+
},
|
|
1211
|
+
"wrapped": {
|
|
1212
|
+
"type": "boolean",
|
|
1213
|
+
"default": false
|
|
1214
|
+
}
|
|
1215
|
+
},
|
|
1216
|
+
"patternProperties": {
|
|
1217
|
+
"^x-": {
|
|
1218
|
+
"$ref": "#/definitions/vendorExtension"
|
|
1219
|
+
}
|
|
1220
|
+
}
|
|
1221
|
+
},
|
|
1222
|
+
"tag": {
|
|
1223
|
+
"type": "object",
|
|
1224
|
+
"additionalProperties": false,
|
|
1225
|
+
"required": [
|
|
1226
|
+
"name"
|
|
1227
|
+
],
|
|
1228
|
+
"properties": {
|
|
1229
|
+
"name": {
|
|
1230
|
+
"type": "string"
|
|
1231
|
+
},
|
|
1232
|
+
"description": {
|
|
1233
|
+
"type": "string"
|
|
1234
|
+
},
|
|
1235
|
+
"externalDocs": {
|
|
1236
|
+
"$ref": "#/definitions/externalDocs"
|
|
1237
|
+
}
|
|
1238
|
+
},
|
|
1239
|
+
"patternProperties": {
|
|
1240
|
+
"^x-": {
|
|
1241
|
+
"$ref": "#/definitions/vendorExtension"
|
|
1242
|
+
}
|
|
1243
|
+
}
|
|
1244
|
+
},
|
|
1245
|
+
"securityDefinitions": {
|
|
1246
|
+
"type": "object",
|
|
1247
|
+
"additionalProperties": {
|
|
1248
|
+
"oneOf": [
|
|
1249
|
+
{
|
|
1250
|
+
"$ref": "#/definitions/basicAuthenticationSecurity"
|
|
1251
|
+
},
|
|
1252
|
+
{
|
|
1253
|
+
"$ref": "#/definitions/apiKeySecurity"
|
|
1254
|
+
},
|
|
1255
|
+
{
|
|
1256
|
+
"$ref": "#/definitions/oauth2ImplicitSecurity"
|
|
1257
|
+
},
|
|
1258
|
+
{
|
|
1259
|
+
"$ref": "#/definitions/oauth2PasswordSecurity"
|
|
1260
|
+
},
|
|
1261
|
+
{
|
|
1262
|
+
"$ref": "#/definitions/oauth2ApplicationSecurity"
|
|
1263
|
+
},
|
|
1264
|
+
{
|
|
1265
|
+
"$ref": "#/definitions/oauth2AccessCodeSecurity"
|
|
1266
|
+
}
|
|
1267
|
+
]
|
|
1268
|
+
}
|
|
1269
|
+
},
|
|
1270
|
+
"basicAuthenticationSecurity": {
|
|
1271
|
+
"type": "object",
|
|
1272
|
+
"additionalProperties": false,
|
|
1273
|
+
"required": [
|
|
1274
|
+
"type"
|
|
1275
|
+
],
|
|
1276
|
+
"properties": {
|
|
1277
|
+
"type": {
|
|
1278
|
+
"type": "string",
|
|
1279
|
+
"enum": [
|
|
1280
|
+
"basic"
|
|
1281
|
+
]
|
|
1282
|
+
},
|
|
1283
|
+
"description": {
|
|
1284
|
+
"type": "string"
|
|
1285
|
+
}
|
|
1286
|
+
},
|
|
1287
|
+
"patternProperties": {
|
|
1288
|
+
"^x-": {
|
|
1289
|
+
"$ref": "#/definitions/vendorExtension"
|
|
1290
|
+
}
|
|
1291
|
+
}
|
|
1292
|
+
},
|
|
1293
|
+
"apiKeySecurity": {
|
|
1294
|
+
"type": "object",
|
|
1295
|
+
"additionalProperties": false,
|
|
1296
|
+
"required": [
|
|
1297
|
+
"type",
|
|
1298
|
+
"name",
|
|
1299
|
+
"in"
|
|
1300
|
+
],
|
|
1301
|
+
"properties": {
|
|
1302
|
+
"type": {
|
|
1303
|
+
"type": "string",
|
|
1304
|
+
"enum": [
|
|
1305
|
+
"apiKey"
|
|
1306
|
+
]
|
|
1307
|
+
},
|
|
1308
|
+
"name": {
|
|
1309
|
+
"type": "string"
|
|
1310
|
+
},
|
|
1311
|
+
"in": {
|
|
1312
|
+
"type": "string",
|
|
1313
|
+
"enum": [
|
|
1314
|
+
"header",
|
|
1315
|
+
"query"
|
|
1316
|
+
]
|
|
1317
|
+
},
|
|
1318
|
+
"description": {
|
|
1319
|
+
"type": "string"
|
|
1320
|
+
}
|
|
1321
|
+
},
|
|
1322
|
+
"patternProperties": {
|
|
1323
|
+
"^x-": {
|
|
1324
|
+
"$ref": "#/definitions/vendorExtension"
|
|
1325
|
+
}
|
|
1326
|
+
}
|
|
1327
|
+
},
|
|
1328
|
+
"oauth2ImplicitSecurity": {
|
|
1329
|
+
"type": "object",
|
|
1330
|
+
"additionalProperties": false,
|
|
1331
|
+
"required": [
|
|
1332
|
+
"type",
|
|
1333
|
+
"flow",
|
|
1334
|
+
"authorizationUrl"
|
|
1335
|
+
],
|
|
1336
|
+
"properties": {
|
|
1337
|
+
"type": {
|
|
1338
|
+
"type": "string",
|
|
1339
|
+
"enum": [
|
|
1340
|
+
"oauth2"
|
|
1341
|
+
]
|
|
1342
|
+
},
|
|
1343
|
+
"flow": {
|
|
1344
|
+
"type": "string",
|
|
1345
|
+
"enum": [
|
|
1346
|
+
"implicit"
|
|
1347
|
+
]
|
|
1348
|
+
},
|
|
1349
|
+
"scopes": {
|
|
1350
|
+
"$ref": "#/definitions/oauth2Scopes"
|
|
1351
|
+
},
|
|
1352
|
+
"authorizationUrl": {
|
|
1353
|
+
"type": "string",
|
|
1354
|
+
"format": "uri"
|
|
1355
|
+
},
|
|
1356
|
+
"description": {
|
|
1357
|
+
"type": "string"
|
|
1358
|
+
}
|
|
1359
|
+
},
|
|
1360
|
+
"patternProperties": {
|
|
1361
|
+
"^x-": {
|
|
1362
|
+
"$ref": "#/definitions/vendorExtension"
|
|
1363
|
+
}
|
|
1364
|
+
}
|
|
1365
|
+
},
|
|
1366
|
+
"oauth2PasswordSecurity": {
|
|
1367
|
+
"type": "object",
|
|
1368
|
+
"additionalProperties": false,
|
|
1369
|
+
"required": [
|
|
1370
|
+
"type",
|
|
1371
|
+
"flow",
|
|
1372
|
+
"tokenUrl"
|
|
1373
|
+
],
|
|
1374
|
+
"properties": {
|
|
1375
|
+
"type": {
|
|
1376
|
+
"type": "string",
|
|
1377
|
+
"enum": [
|
|
1378
|
+
"oauth2"
|
|
1379
|
+
]
|
|
1380
|
+
},
|
|
1381
|
+
"flow": {
|
|
1382
|
+
"type": "string",
|
|
1383
|
+
"enum": [
|
|
1384
|
+
"password"
|
|
1385
|
+
]
|
|
1386
|
+
},
|
|
1387
|
+
"scopes": {
|
|
1388
|
+
"$ref": "#/definitions/oauth2Scopes"
|
|
1389
|
+
},
|
|
1390
|
+
"tokenUrl": {
|
|
1391
|
+
"type": "string",
|
|
1392
|
+
"format": "uri"
|
|
1393
|
+
},
|
|
1394
|
+
"description": {
|
|
1395
|
+
"type": "string"
|
|
1396
|
+
}
|
|
1397
|
+
},
|
|
1398
|
+
"patternProperties": {
|
|
1399
|
+
"^x-": {
|
|
1400
|
+
"$ref": "#/definitions/vendorExtension"
|
|
1401
|
+
}
|
|
1402
|
+
}
|
|
1403
|
+
},
|
|
1404
|
+
"oauth2ApplicationSecurity": {
|
|
1405
|
+
"type": "object",
|
|
1406
|
+
"additionalProperties": false,
|
|
1407
|
+
"required": [
|
|
1408
|
+
"type",
|
|
1409
|
+
"flow",
|
|
1410
|
+
"tokenUrl"
|
|
1411
|
+
],
|
|
1412
|
+
"properties": {
|
|
1413
|
+
"type": {
|
|
1414
|
+
"type": "string",
|
|
1415
|
+
"enum": [
|
|
1416
|
+
"oauth2"
|
|
1417
|
+
]
|
|
1418
|
+
},
|
|
1419
|
+
"flow": {
|
|
1420
|
+
"type": "string",
|
|
1421
|
+
"enum": [
|
|
1422
|
+
"application"
|
|
1423
|
+
]
|
|
1424
|
+
},
|
|
1425
|
+
"scopes": {
|
|
1426
|
+
"$ref": "#/definitions/oauth2Scopes"
|
|
1427
|
+
},
|
|
1428
|
+
"tokenUrl": {
|
|
1429
|
+
"type": "string",
|
|
1430
|
+
"format": "uri"
|
|
1431
|
+
},
|
|
1432
|
+
"description": {
|
|
1433
|
+
"type": "string"
|
|
1434
|
+
}
|
|
1435
|
+
},
|
|
1436
|
+
"patternProperties": {
|
|
1437
|
+
"^x-": {
|
|
1438
|
+
"$ref": "#/definitions/vendorExtension"
|
|
1439
|
+
}
|
|
1440
|
+
}
|
|
1441
|
+
},
|
|
1442
|
+
"oauth2AccessCodeSecurity": {
|
|
1443
|
+
"type": "object",
|
|
1444
|
+
"additionalProperties": false,
|
|
1445
|
+
"required": [
|
|
1446
|
+
"type",
|
|
1447
|
+
"flow",
|
|
1448
|
+
"authorizationUrl",
|
|
1449
|
+
"tokenUrl"
|
|
1450
|
+
],
|
|
1451
|
+
"properties": {
|
|
1452
|
+
"type": {
|
|
1453
|
+
"type": "string",
|
|
1454
|
+
"enum": [
|
|
1455
|
+
"oauth2"
|
|
1456
|
+
]
|
|
1457
|
+
},
|
|
1458
|
+
"flow": {
|
|
1459
|
+
"type": "string",
|
|
1460
|
+
"enum": [
|
|
1461
|
+
"accessCode"
|
|
1462
|
+
]
|
|
1463
|
+
},
|
|
1464
|
+
"scopes": {
|
|
1465
|
+
"$ref": "#/definitions/oauth2Scopes"
|
|
1466
|
+
},
|
|
1467
|
+
"authorizationUrl": {
|
|
1468
|
+
"type": "string",
|
|
1469
|
+
"format": "uri"
|
|
1470
|
+
},
|
|
1471
|
+
"tokenUrl": {
|
|
1472
|
+
"type": "string",
|
|
1473
|
+
"format": "uri"
|
|
1474
|
+
},
|
|
1475
|
+
"description": {
|
|
1476
|
+
"type": "string"
|
|
1477
|
+
}
|
|
1478
|
+
},
|
|
1479
|
+
"patternProperties": {
|
|
1480
|
+
"^x-": {
|
|
1481
|
+
"$ref": "#/definitions/vendorExtension"
|
|
1482
|
+
}
|
|
1483
|
+
}
|
|
1484
|
+
},
|
|
1485
|
+
"oauth2Scopes": {
|
|
1486
|
+
"type": "object",
|
|
1487
|
+
"additionalProperties": {
|
|
1488
|
+
"type": "string"
|
|
1489
|
+
}
|
|
1490
|
+
},
|
|
1491
|
+
"mediaTypeList": {
|
|
1492
|
+
"type": "array",
|
|
1493
|
+
"items": {
|
|
1494
|
+
"$ref": "#/definitions/mimeType"
|
|
1495
|
+
},
|
|
1496
|
+
"uniqueItems": true
|
|
1497
|
+
},
|
|
1498
|
+
"parametersList": {
|
|
1499
|
+
"type": "array",
|
|
1500
|
+
"description": "The parameters needed to send a valid API call.",
|
|
1501
|
+
"additionalItems": false,
|
|
1502
|
+
"items": {
|
|
1503
|
+
"oneOf": [
|
|
1504
|
+
{
|
|
1505
|
+
"$ref": "#/definitions/parameter"
|
|
1506
|
+
},
|
|
1507
|
+
{
|
|
1508
|
+
"$ref": "#/definitions/jsonReference"
|
|
1509
|
+
}
|
|
1510
|
+
]
|
|
1511
|
+
},
|
|
1512
|
+
"uniqueItems": true
|
|
1513
|
+
},
|
|
1514
|
+
"schemesList": {
|
|
1515
|
+
"type": "array",
|
|
1516
|
+
"description": "The transfer protocol of the API.",
|
|
1517
|
+
"items": {
|
|
1518
|
+
"type": "string",
|
|
1519
|
+
"enum": [
|
|
1520
|
+
"http",
|
|
1521
|
+
"https",
|
|
1522
|
+
"ws",
|
|
1523
|
+
"wss"
|
|
1524
|
+
]
|
|
1525
|
+
},
|
|
1526
|
+
"uniqueItems": true
|
|
1527
|
+
},
|
|
1528
|
+
"collectionFormat": {
|
|
1529
|
+
"type": "string",
|
|
1530
|
+
"enum": [
|
|
1531
|
+
"csv",
|
|
1532
|
+
"ssv",
|
|
1533
|
+
"tsv",
|
|
1534
|
+
"pipes"
|
|
1535
|
+
],
|
|
1536
|
+
"default": "csv"
|
|
1537
|
+
},
|
|
1538
|
+
"collectionFormatWithMulti": {
|
|
1539
|
+
"type": "string",
|
|
1540
|
+
"enum": [
|
|
1541
|
+
"csv",
|
|
1542
|
+
"ssv",
|
|
1543
|
+
"tsv",
|
|
1544
|
+
"pipes",
|
|
1545
|
+
"multi"
|
|
1546
|
+
],
|
|
1547
|
+
"default": "csv"
|
|
1548
|
+
},
|
|
1549
|
+
"title": {
|
|
1550
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/title"
|
|
1551
|
+
},
|
|
1552
|
+
"description": {
|
|
1553
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/description"
|
|
1554
|
+
},
|
|
1555
|
+
"default": {
|
|
1556
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/default"
|
|
1557
|
+
},
|
|
1558
|
+
"multipleOf": {
|
|
1559
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/multipleOf"
|
|
1560
|
+
},
|
|
1561
|
+
"maximum": {
|
|
1562
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/maximum"
|
|
1563
|
+
},
|
|
1564
|
+
"exclusiveMaximum": {
|
|
1565
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMaximum"
|
|
1566
|
+
},
|
|
1567
|
+
"minimum": {
|
|
1568
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/minimum"
|
|
1569
|
+
},
|
|
1570
|
+
"exclusiveMinimum": {
|
|
1571
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/exclusiveMinimum"
|
|
1572
|
+
},
|
|
1573
|
+
"maxLength": {
|
|
1574
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
|
|
1575
|
+
},
|
|
1576
|
+
"minLength": {
|
|
1577
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
|
|
1578
|
+
},
|
|
1579
|
+
"pattern": {
|
|
1580
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/pattern"
|
|
1581
|
+
},
|
|
1582
|
+
"maxItems": {
|
|
1583
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveInteger"
|
|
1584
|
+
},
|
|
1585
|
+
"minItems": {
|
|
1586
|
+
"$ref": "http://json-schema.org/draft-04/schema#/definitions/positiveIntegerDefault0"
|
|
1587
|
+
},
|
|
1588
|
+
"uniqueItems": {
|
|
1589
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/uniqueItems"
|
|
1590
|
+
},
|
|
1591
|
+
"enum": {
|
|
1592
|
+
"$ref": "http://json-schema.org/draft-04/schema#/properties/enum"
|
|
1593
|
+
},
|
|
1594
|
+
"jsonReference": {
|
|
1595
|
+
"type": "object",
|
|
1596
|
+
"required": [
|
|
1597
|
+
"$ref"
|
|
1598
|
+
],
|
|
1599
|
+
"additionalProperties": false,
|
|
1600
|
+
"properties": {
|
|
1601
|
+
"$ref": {
|
|
1602
|
+
"type": "string"
|
|
1603
|
+
}
|
|
1604
|
+
}
|
|
1605
|
+
}
|
|
1606
|
+
}
|
|
1607
|
+
}
|