apipie-rails 0.5.6 → 0.5.7

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.
@@ -167,6 +167,10 @@ module Apipie
167
167
  self.new(param_description, argument) if argument.is_a?(Array)
168
168
  end
169
169
 
170
+ def values
171
+ @array
172
+ end
173
+
170
174
  def description
171
175
  string = @array.map { |value| "<code>#{value}</code>" }.join(', ')
172
176
  "Must be one of: #{string}."
@@ -1,3 +1,3 @@
1
1
  module Apipie
2
- VERSION = '0.5.6'
2
+ VERSION = '0.5.7'
3
3
  end
@@ -51,6 +51,71 @@ namespace :apipie do
51
51
  end
52
52
  end
53
53
 
54
+ desc "Generate static swagger json"
55
+ task :static_swagger_json, [:version, :swagger_content_type_input, :filename_suffix] => :environment do |t, args|
56
+ with_loaded_documentation do
57
+ out = ENV["OUT"] || File.join(::Rails.root, Apipie.configuration.doc_path, 'apidoc')
58
+ generate_swagger_using_args(args, out)
59
+ end
60
+ end
61
+
62
+ # The following task compares the currently-generated swagger output to a reference copy generated
63
+ # by the previous execution of this task.
64
+ # if a difference is detected, the current output will be stored as a reference.
65
+ # reference files have the
66
+ # if more than 3 references are detected, the older ones will be purged
67
+ desc "Did swagger output change since the last execution of this task?"
68
+ task :did_swagger_change, [:version, :swagger_content_type_input, :filename_suffix] => :environment do |t, args|
69
+ with_loaded_documentation do
70
+ out = ENV["OUT_REF"] || File.join(::Rails.root, Apipie.configuration.doc_path, 'apidoc_ref')
71
+ paths = generate_swagger_using_args(args, out)
72
+ paths.each {|path|
73
+ existing_files_in_dir = Pathname(out).children(true)
74
+
75
+ make_reference = false
76
+
77
+ # reference filenames have the format <basename>.<counter>.swagger_ref
78
+ reference_files = existing_files_in_dir.select{|f|
79
+ f.extname == '.swagger_ref' &&
80
+ f.basename.sub_ext("").extname.delete('.').to_i > 0 &&
81
+ f.basename.sub_ext("").sub_ext("") == path.basename.sub_ext("")
82
+ }
83
+ if reference_files.empty?
84
+ print "Reference file does not exist for [#{path}]\n"
85
+ counter = 1
86
+ make_reference = true
87
+ else
88
+ reference_files.sort_by! {|f| f.ctime }
89
+ last_ref = reference_files[-1]
90
+ print "Comparing [#{path}] to reference file: [#{last_ref.basename}]: "
91
+ if !FileUtils.compare_file(path, last_ref)
92
+ print("\n ---> Differences detected\n")
93
+ counter = last_ref.sub_ext("").extname.delete('.').to_i + 1
94
+ make_reference = true
95
+ else
96
+ print("identical\n")
97
+ end
98
+ end
99
+
100
+ if make_reference
101
+ new_path = path.sub_ext(".#{counter}.swagger_ref")
102
+ print " ---> Keeping current output as [#{new_path}]\n"
103
+ path.rename(new_path)
104
+ reference_files << new_path
105
+ else
106
+ path.delete
107
+ end
108
+
109
+ num_refs_to_keep = 3
110
+ if reference_files.length > num_refs_to_keep
111
+ (reference_files - reference_files[-num_refs_to_keep..-1]).each{|f| f.delete}
112
+ end
113
+ }
114
+ end
115
+ end
116
+
117
+
118
+
54
119
  # By default the full cache is built.
55
120
  # It is possible to generate index resp. resources only with
56
121
  # rake apipie:cache cache_part=index (resources resp.)
@@ -124,6 +189,26 @@ namespace :apipie do
124
189
  end
125
190
  end
126
191
 
192
+ def generate_swagger_using_args(args, out)
193
+ args.with_defaults(:version => Apipie.configuration.default_version,
194
+ :swagger_content_type_input => :form_data,
195
+ :filename_suffix => nil)
196
+ Apipie.configuration.swagger_content_type_input = args[:swagger_content_type_input].to_sym
197
+ count = 0
198
+
199
+ sfx = args[:filename_suffix] || "_#{args[:swagger_content_type_input]}"
200
+
201
+ paths = []
202
+
203
+ ([nil] + Apipie.configuration.languages).each do |lang|
204
+ doc = Apipie.to_swagger_json(args[:version], nil, nil, lang, count==0)
205
+ paths << generate_swagger_json_page(out, doc, sfx, lang)
206
+ count+=1
207
+ end
208
+
209
+ paths
210
+ end
211
+
127
212
  def generate_json_page(file_base, doc, lang = nil)
128
213
  FileUtils.mkdir_p(file_base) unless File.exists?(file_base)
129
214
 
@@ -131,6 +216,15 @@ namespace :apipie do
131
216
  File.open("#{file_base}/#{filename}", 'w') { |file| file.write(JSON.pretty_generate(doc)) }
132
217
  end
133
218
 
219
+ def generate_swagger_json_page(file_base, doc, sfx="", lang = nil)
220
+ FileUtils.mkdir_p(file_base) unless File.exists?(file_base)
221
+
222
+ path = Pathname.new("#{file_base}/schema_swagger#{sfx}#{lang_ext(lang)}.json")
223
+ File.open(path, 'w') { |file| file.write(JSON.pretty_generate(doc)) }
224
+
225
+ path
226
+ end
227
+
134
228
  def generate_one_page(file_base, doc, lang = nil)
135
229
  FileUtils.mkdir_p(File.dirname(file_base)) unless File.exists?(File.dirname(file_base))
136
230
 
@@ -225,7 +319,7 @@ MESSAGE
225
319
  apis_from_routes.each do |(controller, action), apis|
226
320
  next if ignored.include?(controller)
227
321
  next if ignored.include?("#{controller}##{action}")
228
- Apipie::Extractor::Writer.update_action_description(controller.constantize, action) do |u|
322
+ Apipie::Extractor::Writer.update_action_description((controller.safe_constantize || next), action) do |u|
229
323
  u.update_apis(apis)
230
324
  end
231
325
  end
@@ -1,5 +1,6 @@
1
1
  require 'spec_helper'
2
2
  require 'fileutils'
3
+ require "json-schema"
3
4
 
4
5
  describe Apipie::ApipiesController do
5
6
 
@@ -130,6 +131,36 @@ describe Apipie::ApipiesController do
130
131
  end
131
132
  end
132
133
 
134
+ describe "GET index as swagger" do
135
+
136
+ let(:swagger_schema) do
137
+ File.read(File.join(File.dirname(__FILE__),"../lib/swagger/openapi_2_0_schema.json"))
138
+ end
139
+
140
+ it "outputs swagger when format is json and type is swagger" do
141
+ get :index, :params => { :format => "json", :type => "swagger"}
142
+
143
+ assert_response :success
144
+ expect(response.body).to match(/"swagger":"2.0"/)
145
+ expect(JSON::Validator.validate(swagger_schema, response.body)).to be_truthy
146
+ end
147
+
148
+ it "does not output swagger when format is not json even if type is swagger" do
149
+ get :index, :params => { :type => "swagger"}
150
+
151
+ assert_response :success
152
+ expect(response.body).not_to match(/"swagger":"2.0"/)
153
+ end
154
+
155
+ it "does not output swagger when format is json even but type is not swagger" do
156
+ get :index, :params => { :format => "json"}
157
+
158
+ assert_response :success
159
+ expect(response.body).not_to match(/"swagger":"2.0"/)
160
+ end
161
+ end
162
+
163
+
133
164
  describe "authenticate user" do
134
165
  it "authenticate user if an authentication method is setted" do
135
166
  test = false
@@ -183,6 +214,11 @@ describe Apipie::ApipiesController do
183
214
  expect(assigns(:doc)[:resources]["users"][:methods].size).to eq(users_methods - 1)
184
215
  expect(assigns(:doc)[:resources]["twitter_example"][:methods].size).to eq(twitter_example_methods)
185
216
  end
217
+ it "does not allow access to swagger when authorization is set" do
218
+ get :index, :params => { :format => "json", :type => "swagger"}
219
+
220
+ assert_response :forbidden
221
+ end
186
222
  end
187
223
 
188
224
  describe "documentation cache" do
@@ -230,4 +266,6 @@ describe Apipie::ApipiesController do
230
266
  end
231
267
 
232
268
  end
269
+
270
+
233
271
  end
@@ -268,6 +268,11 @@ class UsersController < ApplicationController
268
268
  render :plain => 'This is very similar to create action'
269
269
  end
270
270
 
271
+ api :GET, '/users/by_department', 'show users from a specific department'
272
+ param :department, ["finance", "operations", "sales", "marketing", "HR"], required: false, default_value: "sales"
273
+ def get_by_department
274
+ render :plain => 'nothing to see here'
275
+ end
271
276
 
272
277
  api :GET, '/users/desc_from_file', 'desc from file'
273
278
  document 'users/desc_from_file.md'
@@ -12,6 +12,11 @@ Dummy::Application.routes.draw do
12
12
  namespace :files do
13
13
  get '/*file_path', format: false, :action => 'download'
14
14
  end
15
+
16
+ # This is not directly used in the specs.
17
+ # It is only there to tests apipies tolerance regarding
18
+ # missing controllers.
19
+ resources :dangeling_stuff
15
20
  resources :twitter_example do
16
21
  collection do
17
22
  get :lookup
@@ -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 responses"
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
+ }