swagger-diff 1.0.5 → 1.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.rubocop.yml +1 -1
- data/.ruby-version +1 -1
- data/.travis.yml +8 -0
- data/CHANGELOG.md +51 -12
- data/CODE_OF_CONDUCT.md +50 -0
- data/CONTRIBUTING.md +3 -1
- data/{LICENSE.txt → LICENSE.md} +0 -0
- data/README.md +62 -11
- data/exe/swagger-diff +39 -7
- data/lib/swagger/diff.rb +5 -3
- data/lib/swagger/diff/diff.rb +110 -37
- data/lib/swagger/diff/specification.rb +110 -38
- data/lib/swagger/diff/version.rb +1 -1
- data/schema/json/LICENSE.md +25 -0
- data/schema/json/schema.json +150 -0
- data/schema/oai/LICENSE.md +11 -0
- data/schema/oai/schema.json +1607 -0
- data/swagger-diff.gemspec +15 -9
- metadata +25 -22
- data/lib/swagger/diff/patch.rb +0 -29
@@ -4,6 +4,7 @@ module Swagger
|
|
4
4
|
def initialize(spec)
|
5
5
|
@spec = spec
|
6
6
|
@parsed = parse_swagger(spec)
|
7
|
+
validate_swagger
|
7
8
|
@endpoint_hash = parsed_to_hash(@parsed)
|
8
9
|
end
|
9
10
|
|
@@ -44,16 +45,16 @@ module Swagger
|
|
44
45
|
end
|
45
46
|
|
46
47
|
def params_or_nil(endpoint)
|
47
|
-
endpoint && endpoint
|
48
|
+
endpoint && endpoint['parameters'] || nil
|
48
49
|
end
|
49
50
|
|
50
51
|
def parse_swagger(swagger)
|
51
52
|
if swagger.is_a? Hash
|
52
|
-
|
53
|
-
elsif File.exist?(swagger)
|
54
|
-
Swagger.load(swagger)
|
53
|
+
swagger
|
55
54
|
else
|
56
|
-
|
55
|
+
if File.exist?(swagger) || swagger[0..7] =~ %r{^https?://}
|
56
|
+
swagger = open(swagger).read
|
57
|
+
end
|
57
58
|
begin
|
58
59
|
JSON.parse(swagger)
|
59
60
|
rescue JSON::ParserError
|
@@ -61,19 +62,27 @@ module Swagger
|
|
61
62
|
YAML.load(swagger)
|
62
63
|
rescue Psych::SyntaxError
|
63
64
|
raise 'Only filenames or raw or parsed strings of JSON or YAML are supported.'
|
64
|
-
else
|
65
|
-
Swagger.build(swagger, format: :yaml)
|
66
65
|
end
|
67
|
-
else
|
68
|
-
Swagger.build(swagger, format: :json)
|
69
66
|
end
|
70
67
|
end
|
71
68
|
end
|
72
69
|
|
73
70
|
def parsed_to_hash(parsed)
|
74
71
|
ret = {}
|
75
|
-
|
76
|
-
|
72
|
+
verbs = Set['get', 'put', 'post', 'delete', 'options', 'head', 'patch']
|
73
|
+
parsed['paths'].each do |path, items|
|
74
|
+
# TODO: this doesn't handle external definitions ($ref).
|
75
|
+
warn 'External definitions are not (yet) supported' if items.key?('$ref')
|
76
|
+
(verbs & items.keys).each do |verb|
|
77
|
+
if items['parameters']
|
78
|
+
if items[verb]['parameters']
|
79
|
+
items[verb]['parameters'].concat(items['parameters'])
|
80
|
+
else
|
81
|
+
items[verb]['parameters'] = items['parameters']
|
82
|
+
end
|
83
|
+
end
|
84
|
+
ret["#{verb} #{path.gsub(/{.*?}/, '{}')}"] = items[verb]
|
85
|
+
end
|
77
86
|
end
|
78
87
|
ret
|
79
88
|
end
|
@@ -84,9 +93,19 @@ module Swagger
|
|
84
93
|
# parameter definitions (i.e., all parameters, including nested
|
85
94
|
# parameters, are included in a single set).
|
86
95
|
def refs(ref, prefix = '')
|
96
|
+
defs = if ref[0..12] == '#/parameters/'
|
97
|
+
@parsed['parameters']
|
98
|
+
elsif ref[0..11] == '#/responses/'
|
99
|
+
@parsed['responses']
|
100
|
+
elsif ref[0..13] == '#/definitions/'
|
101
|
+
@parsed['definitions']
|
102
|
+
else
|
103
|
+
warn "Unsupported ref '#{ref}' (expected definitions, parameters, or responses)"
|
104
|
+
{}
|
105
|
+
end
|
87
106
|
idx = ref.rindex('/')
|
88
107
|
key = ref[idx + 1..-1]
|
89
|
-
schema(
|
108
|
+
schema(defs.fetch(key, {}), prefix)
|
90
109
|
end
|
91
110
|
|
92
111
|
def all_of!(definitions, prefix, ret)
|
@@ -101,26 +120,35 @@ module Swagger
|
|
101
120
|
end
|
102
121
|
|
103
122
|
def array?(definition)
|
104
|
-
definition
|
123
|
+
definition['type'] && definition['type'] == 'array' && definition['items']
|
105
124
|
end
|
106
125
|
|
126
|
+
# rubocop:disable Metrics/AbcSize
|
127
|
+
# rubocop:disable Metrics/CyclomaticComplexity
|
107
128
|
def schema(definition, prefix = '')
|
108
129
|
ret = { required: Set.new, all: Set.new }
|
109
|
-
if definition
|
110
|
-
all_of!(definition
|
130
|
+
if definition['allOf']
|
131
|
+
all_of!(definition['allOf'], prefix, ret)
|
111
132
|
elsif definition['$ref']
|
112
133
|
merge_refs!(ret, refs(definition['$ref'], prefix))
|
113
|
-
elsif definition
|
134
|
+
elsif definition['properties']
|
114
135
|
merge_refs!(ret,
|
115
|
-
properties(definition
|
116
|
-
definition
|
136
|
+
properties(definition['properties'],
|
137
|
+
definition['required'], prefix))
|
117
138
|
elsif array?(definition)
|
118
|
-
merge_refs!(ret, schema(definition
|
119
|
-
elsif definition
|
139
|
+
merge_refs!(ret, schema(definition['items'], "#{prefix}[]/"))
|
140
|
+
elsif definition['type'] == 'object'
|
120
141
|
ret[:all].add(hash_property(definition, prefix))
|
142
|
+
elsif definition['in']
|
143
|
+
merge_refs!(ret,
|
144
|
+
properties_for_param(prefix, definition))
|
145
|
+
elsif definition['schema']
|
146
|
+
merge_refs!(ret, schema(definition['schema']))
|
121
147
|
end
|
122
148
|
ret
|
123
149
|
end
|
150
|
+
# rubocop:enable Metrics/CyclomaticComplexity
|
151
|
+
# rubocop:enable Metrics/AbcSize
|
124
152
|
|
125
153
|
def nested(ref, prefix, name, list = false)
|
126
154
|
# Check for cycles by testing whether name was already added to
|
@@ -135,6 +163,15 @@ module Swagger
|
|
135
163
|
end
|
136
164
|
end
|
137
165
|
|
166
|
+
def properties_for_param(prefix, definition)
|
167
|
+
required = if definition['required']
|
168
|
+
[definition['name']]
|
169
|
+
else
|
170
|
+
[]
|
171
|
+
end
|
172
|
+
properties_for_ref(prefix, definition['name'], definition, required)
|
173
|
+
end
|
174
|
+
|
138
175
|
def properties_for_ref(prefix, name, schema, required, list = false)
|
139
176
|
key = "#{prefix}#{name}"
|
140
177
|
ret = { required: Set.new, all: Set.new }
|
@@ -142,7 +179,12 @@ module Swagger
|
|
142
179
|
merge_refs!(ret, nested(schema['$ref'], prefix, name, list))
|
143
180
|
else
|
144
181
|
ret[:required].add(key) if required && required.include?(name)
|
145
|
-
|
182
|
+
loc = if schema['in']
|
183
|
+
schema['in']
|
184
|
+
else
|
185
|
+
'body'
|
186
|
+
end
|
187
|
+
ret[:all].add("#{key} (in: #{loc}, type: #{schema['type']}#{'[]' if list})")
|
146
188
|
end
|
147
189
|
ret
|
148
190
|
end
|
@@ -160,9 +202,9 @@ module Swagger
|
|
160
202
|
else
|
161
203
|
"#{prefix}#{name}"
|
162
204
|
end
|
163
|
-
type = if definition
|
164
|
-
definition
|
165
|
-
definition
|
205
|
+
type = if definition['additionalProperties'] &&
|
206
|
+
definition['additionalProperties']['type']
|
207
|
+
definition['additionalProperties']['type']
|
166
208
|
else
|
167
209
|
'*'
|
168
210
|
end
|
@@ -172,10 +214,10 @@ module Swagger
|
|
172
214
|
def properties(properties, required, prefix = '')
|
173
215
|
ret = { required: Set.new, all: Set.new }
|
174
216
|
properties.each do |name, schema|
|
175
|
-
if schema
|
176
|
-
merge_refs!(ret, properties_for_ref(prefix, name, schema
|
177
|
-
elsif schema
|
178
|
-
if schema
|
217
|
+
if schema['type'] == 'array'
|
218
|
+
merge_refs!(ret, properties_for_ref(prefix, name, schema['items'], required, true))
|
219
|
+
elsif schema['type'] == 'object'
|
220
|
+
if schema['allOf']
|
179
221
|
# TODO: handle nested allOfs.
|
180
222
|
else
|
181
223
|
ret[:all].add(hash_property(schema, prefix, name))
|
@@ -191,11 +233,13 @@ module Swagger
|
|
191
233
|
ret = { required: Set.new, all: Set.new }
|
192
234
|
return ret if params.nil?
|
193
235
|
params.each do |param|
|
194
|
-
if param
|
195
|
-
merge_refs!(ret, schema(param
|
236
|
+
if param['in'] == 'body'
|
237
|
+
merge_refs!(ret, schema(param['schema']))
|
238
|
+
elsif param['$ref']
|
239
|
+
merge_refs!(ret, schema(param))
|
196
240
|
else
|
197
|
-
ret[:required].add(param
|
198
|
-
ret[:all].add("#{param
|
241
|
+
ret[:required].add(param['name']) if param['required']
|
242
|
+
ret[:all].add("#{param['name']} (in: #{param['in']}, type: #{param['type']})")
|
199
243
|
end
|
200
244
|
end
|
201
245
|
ret
|
@@ -203,15 +247,43 @@ module Swagger
|
|
203
247
|
|
204
248
|
def response_attributes_inner(endpoint)
|
205
249
|
ret = {}
|
206
|
-
endpoint
|
207
|
-
if response
|
208
|
-
|
209
|
-
|
210
|
-
|
211
|
-
|
250
|
+
endpoint['responses'].each do |code, response|
|
251
|
+
ret[code] = if response['schema']
|
252
|
+
schema(response['schema'])[:all]
|
253
|
+
elsif response['$ref']
|
254
|
+
schema(response)[:all]
|
255
|
+
else
|
256
|
+
Set.new
|
257
|
+
end
|
212
258
|
end
|
213
259
|
ret
|
214
260
|
end
|
261
|
+
|
262
|
+
def schema_for(type)
|
263
|
+
File.join(
|
264
|
+
File.expand_path(File.join('..', '..', '..', '..'), __FILE__),
|
265
|
+
'schema', type, 'schema.json'
|
266
|
+
)
|
267
|
+
end
|
268
|
+
|
269
|
+
def validate_swagger
|
270
|
+
json_schema = File.open(schema_for('json')) do |json_schema_file|
|
271
|
+
JSON::Schema.new(
|
272
|
+
JSON.parse(json_schema_file.read),
|
273
|
+
Addressable::URI.parse('http://json-schema.org/draft-04/schema#')
|
274
|
+
)
|
275
|
+
end
|
276
|
+
JSON::Validator.add_schema(json_schema)
|
277
|
+
errors = JSON::Validator.fully_validate(schema_for('oai'), JSON.dump(@parsed))
|
278
|
+
unless errors.empty?
|
279
|
+
spec = if @spec.to_s.length > 80
|
280
|
+
"#{@spec.to_s[0..74]} ..."
|
281
|
+
else
|
282
|
+
@spec
|
283
|
+
end
|
284
|
+
warn "#{spec} is not a valid Swagger specification:\n\n#{errors.join("\n")}"
|
285
|
+
end
|
286
|
+
end
|
215
287
|
end
|
216
288
|
end
|
217
289
|
end
|
data/lib/swagger/diff/version.rb
CHANGED
@@ -0,0 +1,25 @@
|
|
1
|
+
Copyright (c) 2016 IETF Trust and the persons identified as authors of the code.
|
2
|
+
All rights reserved.
|
3
|
+
|
4
|
+
Redistribution and use in source and binary forms, with or without
|
5
|
+
modification, are permitted provided that the following conditions are met:
|
6
|
+
|
7
|
+
* Redistributions of source code must retain the above copyright notice, this
|
8
|
+
list of conditions and the following disclaimer.
|
9
|
+
* Redistributions in binary form must reproduce the above copyright notice,
|
10
|
+
this list of conditions and the following disclaimer in the documentation
|
11
|
+
and/or other materials provided with the distribution.
|
12
|
+
* Neither the name of Internet Society, IETF or IETF Trust, nor the names of
|
13
|
+
specific contributors, may be used to endorse or promote products derived
|
14
|
+
from this software without specific prior written permission.
|
15
|
+
|
16
|
+
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
|
17
|
+
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
18
|
+
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
19
|
+
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
|
20
|
+
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
21
|
+
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
22
|
+
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
23
|
+
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
24
|
+
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
25
|
+
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
@@ -0,0 +1,150 @@
|
|
1
|
+
{
|
2
|
+
"id": "http://json-schema.org/draft-04/schema#",
|
3
|
+
"$schema": "http://json-schema.org/draft-04/schema#",
|
4
|
+
"description": "Core schema meta-schema",
|
5
|
+
"definitions": {
|
6
|
+
"schemaArray": {
|
7
|
+
"type": "array",
|
8
|
+
"minItems": 1,
|
9
|
+
"items": { "$ref": "#" }
|
10
|
+
},
|
11
|
+
"positiveInteger": {
|
12
|
+
"type": "integer",
|
13
|
+
"minimum": 0
|
14
|
+
},
|
15
|
+
"positiveIntegerDefault0": {
|
16
|
+
"allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
|
17
|
+
},
|
18
|
+
"simpleTypes": {
|
19
|
+
"enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
|
20
|
+
},
|
21
|
+
"stringArray": {
|
22
|
+
"type": "array",
|
23
|
+
"items": { "type": "string" },
|
24
|
+
"minItems": 1,
|
25
|
+
"uniqueItems": true
|
26
|
+
}
|
27
|
+
},
|
28
|
+
"type": "object",
|
29
|
+
"properties": {
|
30
|
+
"id": {
|
31
|
+
"type": "string",
|
32
|
+
"format": "uri"
|
33
|
+
},
|
34
|
+
"$schema": {
|
35
|
+
"type": "string",
|
36
|
+
"format": "uri"
|
37
|
+
},
|
38
|
+
"title": {
|
39
|
+
"type": "string"
|
40
|
+
},
|
41
|
+
"description": {
|
42
|
+
"type": "string"
|
43
|
+
},
|
44
|
+
"default": {},
|
45
|
+
"multipleOf": {
|
46
|
+
"type": "number",
|
47
|
+
"minimum": 0,
|
48
|
+
"exclusiveMinimum": true
|
49
|
+
},
|
50
|
+
"maximum": {
|
51
|
+
"type": "number"
|
52
|
+
},
|
53
|
+
"exclusiveMaximum": {
|
54
|
+
"type": "boolean",
|
55
|
+
"default": false
|
56
|
+
},
|
57
|
+
"minimum": {
|
58
|
+
"type": "number"
|
59
|
+
},
|
60
|
+
"exclusiveMinimum": {
|
61
|
+
"type": "boolean",
|
62
|
+
"default": false
|
63
|
+
},
|
64
|
+
"maxLength": { "$ref": "#/definitions/positiveInteger" },
|
65
|
+
"minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
|
66
|
+
"pattern": {
|
67
|
+
"type": "string",
|
68
|
+
"format": "regex"
|
69
|
+
},
|
70
|
+
"additionalItems": {
|
71
|
+
"anyOf": [
|
72
|
+
{ "type": "boolean" },
|
73
|
+
{ "$ref": "#" }
|
74
|
+
],
|
75
|
+
"default": {}
|
76
|
+
},
|
77
|
+
"items": {
|
78
|
+
"anyOf": [
|
79
|
+
{ "$ref": "#" },
|
80
|
+
{ "$ref": "#/definitions/schemaArray" }
|
81
|
+
],
|
82
|
+
"default": {}
|
83
|
+
},
|
84
|
+
"maxItems": { "$ref": "#/definitions/positiveInteger" },
|
85
|
+
"minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
|
86
|
+
"uniqueItems": {
|
87
|
+
"type": "boolean",
|
88
|
+
"default": false
|
89
|
+
},
|
90
|
+
"maxProperties": { "$ref": "#/definitions/positiveInteger" },
|
91
|
+
"minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
|
92
|
+
"required": { "$ref": "#/definitions/stringArray" },
|
93
|
+
"additionalProperties": {
|
94
|
+
"anyOf": [
|
95
|
+
{ "type": "boolean" },
|
96
|
+
{ "$ref": "#" }
|
97
|
+
],
|
98
|
+
"default": {}
|
99
|
+
},
|
100
|
+
"definitions": {
|
101
|
+
"type": "object",
|
102
|
+
"additionalProperties": { "$ref": "#" },
|
103
|
+
"default": {}
|
104
|
+
},
|
105
|
+
"properties": {
|
106
|
+
"type": "object",
|
107
|
+
"additionalProperties": { "$ref": "#" },
|
108
|
+
"default": {}
|
109
|
+
},
|
110
|
+
"patternProperties": {
|
111
|
+
"type": "object",
|
112
|
+
"additionalProperties": { "$ref": "#" },
|
113
|
+
"default": {}
|
114
|
+
},
|
115
|
+
"dependencies": {
|
116
|
+
"type": "object",
|
117
|
+
"additionalProperties": {
|
118
|
+
"anyOf": [
|
119
|
+
{ "$ref": "#" },
|
120
|
+
{ "$ref": "#/definitions/stringArray" }
|
121
|
+
]
|
122
|
+
}
|
123
|
+
},
|
124
|
+
"enum": {
|
125
|
+
"type": "array",
|
126
|
+
"minItems": 1,
|
127
|
+
"uniqueItems": true
|
128
|
+
},
|
129
|
+
"type": {
|
130
|
+
"anyOf": [
|
131
|
+
{ "$ref": "#/definitions/simpleTypes" },
|
132
|
+
{
|
133
|
+
"type": "array",
|
134
|
+
"items": { "$ref": "#/definitions/simpleTypes" },
|
135
|
+
"minItems": 1,
|
136
|
+
"uniqueItems": true
|
137
|
+
}
|
138
|
+
]
|
139
|
+
},
|
140
|
+
"allOf": { "$ref": "#/definitions/schemaArray" },
|
141
|
+
"anyOf": { "$ref": "#/definitions/schemaArray" },
|
142
|
+
"oneOf": { "$ref": "#/definitions/schemaArray" },
|
143
|
+
"not": { "$ref": "#" }
|
144
|
+
},
|
145
|
+
"dependencies": {
|
146
|
+
"exclusiveMaximum": [ "maximum" ],
|
147
|
+
"exclusiveMinimum": [ "minimum" ]
|
148
|
+
},
|
149
|
+
"default": {}
|
150
|
+
}
|
@@ -0,0 +1,11 @@
|
|
1
|
+
Copyright 2016 The Linux Foundation
|
2
|
+
|
3
|
+
Licensed under the Apache License, Version 2.0 (the "License");
|
4
|
+
you may not use this file except in compliance with the License.
|
5
|
+
You may obtain a copy of the License at [apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
|
6
|
+
|
7
|
+
Unless required by applicable law or agreed to in writing, software
|
8
|
+
distributed under the License is distributed on an "AS IS" BASIS,
|
9
|
+
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
10
|
+
See the License for the specific language governing permissions and
|
11
|
+
limitations under the License.
|
@@ -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
|
+
}
|