1 | declare namespace SwaggerIo {
|
2 | namespace V2 {
|
3 | interface SchemaJson {
|
4 | swagger: '2.0';
|
5 | info: SchemaJson.Definitions.Info;
|
6 | host?: string;
|
7 | basePath?: string;
|
8 | schemes?: SchemaJson.Definitions.SchemesList;
|
9 | consumes?: SchemaJson.Definitions.MimeType[];
|
10 | produces?: SchemaJson.Definitions.MimeType[];
|
11 | paths: SchemaJson.Definitions.Paths;
|
12 | definitions?: SchemaJson.Definitions.Definitions;
|
13 | parameters?: SchemaJson.Definitions.ParameterDefinitions;
|
14 | responses?: SchemaJson.Definitions.ResponseDefinitions;
|
15 | security?: SchemaJson.Definitions.Security;
|
16 | securityDefinitions?: SchemaJson.Definitions.SecurityDefinitions;
|
17 | tags?: SchemaJson.Definitions.Tag[];
|
18 | externalDocs?: SchemaJson.Definitions.ExternalDocs;
|
19 | }
|
20 | namespace SchemaJson {
|
21 | namespace Definitions {
|
22 | interface ApiKeySecurity {
|
23 | type: 'apiKey';
|
24 | name: string;
|
25 | in: 'header' | 'query';
|
26 | description?: string;
|
27 | }
|
28 | interface BasicAuthenticationSecurity {
|
29 | type: 'basic';
|
30 | description?: string;
|
31 | }
|
32 | interface BodyParameter {
|
33 | description?: string;
|
34 | name: string;
|
35 | in: 'body';
|
36 | required?: boolean;
|
37 | schema: JsonSchemaOrg.Draft04.Schema;
|
38 | }
|
39 | type CollectionFormat = 'csv' | 'ssv' | 'tsv' | 'pipes';
|
40 | type CollectionFormatWithMulti = 'csv' | 'ssv' | 'tsv' | 'pipes' | 'multi';
|
41 | interface Contact {
|
42 | name?: string;
|
43 | url?: string;
|
44 | email?: string;
|
45 | }
|
46 | type Default = JsonSchemaOrg.Draft04.Schema.Properties.Default;
|
47 | interface Definitions {
|
48 | [name: string]: JsonSchemaOrg.Draft04.Schema;
|
49 | }
|
50 | type Enum = JsonSchemaOrg.Draft04.Schema.Properties.Enum;
|
51 | interface Examples {
|
52 | [name: string]: any;
|
53 | }
|
54 | type ExclusiveMaximum = JsonSchemaOrg.Draft04.Schema.Properties.ExclusiveMaximum;
|
55 | type ExclusiveMinimum = JsonSchemaOrg.Draft04.Schema.Properties.ExclusiveMinimum;
|
56 | interface ExternalDocs {
|
57 | description?: string;
|
58 | url: string;
|
59 | }
|
60 | interface FileSchema {
|
61 | format?: string;
|
62 | title?: JsonSchemaOrg.Draft04.Schema.Properties.Title;
|
63 | description?: JsonSchemaOrg.Draft04.Schema.Properties.Description;
|
64 | default?: JsonSchemaOrg.Draft04.Schema.Properties.Default;
|
65 | required?: JsonSchemaOrg.Draft04.Schema.Definitions.StringArray;
|
66 | type: 'file';
|
67 | readOnly?: boolean;
|
68 | externalDocs?: ExternalDocs;
|
69 | example?: any;
|
70 | }
|
71 | interface FormDataParameterSubSchema {
|
72 | required?: boolean;
|
73 | in?: 'formData';
|
74 | description?: string;
|
75 | name?: string;
|
76 | allowEmptyValue?: boolean;
|
77 | type?: 'string' | 'number' | 'boolean' | 'integer' | 'array' | 'file';
|
78 | format?: string;
|
79 | items?: PrimitivesItems;
|
80 | collectionFormat?: CollectionFormatWithMulti;
|
81 | default?: Default;
|
82 | maximum?: Maximum;
|
83 | exclusiveMaximum?: ExclusiveMaximum;
|
84 | minimum?: Minimum;
|
85 | exclusiveMinimum?: ExclusiveMinimum;
|
86 | maxLength?: MaxLength;
|
87 | minLength?: MinLength;
|
88 | pattern?: Pattern;
|
89 | maxItems?: MaxItems;
|
90 | minItems?: MinItems;
|
91 | uniqueItems?: UniqueItems;
|
92 | enum?: Enum;
|
93 | multipleOf?: MultipleOf;
|
94 | }
|
95 | interface Header {
|
96 | type: 'string' | 'number' | 'integer' | 'boolean' | 'array';
|
97 | format?: string;
|
98 | items?: PrimitivesItems;
|
99 | collectionFormat?: CollectionFormat;
|
100 | default?: Default;
|
101 | maximum?: Maximum;
|
102 | exclusiveMaximum?: ExclusiveMaximum;
|
103 | minimum?: Minimum;
|
104 | exclusiveMinimum?: ExclusiveMinimum;
|
105 | maxLength?: MaxLength;
|
106 | minLength?: MinLength;
|
107 | pattern?: Pattern;
|
108 | maxItems?: MaxItems;
|
109 | minItems?: MinItems;
|
110 | uniqueItems?: UniqueItems;
|
111 | enum?: Enum;
|
112 | multipleOf?: MultipleOf;
|
113 | description?: string;
|
114 | }
|
115 | interface HeaderParameterSubSchema {
|
116 | required?: boolean;
|
117 | in?: 'header';
|
118 | description?: string;
|
119 | name?: string;
|
120 | type?: 'string' | 'number' | 'boolean' | 'integer' | 'array';
|
121 | format?: string;
|
122 | items?: PrimitivesItems;
|
123 | collectionFormat?: CollectionFormat;
|
124 | default?: Default;
|
125 | maximum?: Maximum;
|
126 | exclusiveMaximum?: ExclusiveMaximum;
|
127 | minimum?: Minimum;
|
128 | exclusiveMinimum?: ExclusiveMinimum;
|
129 | maxLength?: MaxLength;
|
130 | minLength?: MinLength;
|
131 | pattern?: Pattern;
|
132 | maxItems?: MaxItems;
|
133 | minItems?: MinItems;
|
134 | uniqueItems?: UniqueItems;
|
135 | enum?: Enum;
|
136 | multipleOf?: MultipleOf;
|
137 | }
|
138 | interface Headers {
|
139 | [name: string]: Header;
|
140 | }
|
141 | interface Info {
|
142 | title: string;
|
143 | version: string;
|
144 | description?: string;
|
145 | termsOfService?: string;
|
146 | contact?: Contact;
|
147 | license?: License;
|
148 | }
|
149 | interface JsonReference {
|
150 | $ref: string;
|
151 | }
|
152 | interface License {
|
153 | name: string;
|
154 | url?: string;
|
155 | }
|
156 | type MaxItems = JsonSchemaOrg.Draft04.Schema.Definitions.PositiveInteger;
|
157 | type MaxLength = JsonSchemaOrg.Draft04.Schema.Definitions.PositiveInteger;
|
158 | type Maximum = JsonSchemaOrg.Draft04.Schema.Properties.Maximum;
|
159 | type MediaTypeList = MimeType[];
|
160 | type MimeType = string;
|
161 | type MinItems = JsonSchemaOrg.Draft04.Schema.Definitions.PositiveIntegerDefault0;
|
162 | type MinLength = JsonSchemaOrg.Draft04.Schema.Definitions.PositiveIntegerDefault0;
|
163 | type Minimum = JsonSchemaOrg.Draft04.Schema.Properties.Minimum;
|
164 | type MultipleOf = JsonSchemaOrg.Draft04.Schema.Properties.MultipleOf;
|
165 | interface NonBodyParameter {
|
166 | }
|
167 | interface Oauth2AccessCodeSecurity {
|
168 | type: 'oauth2';
|
169 | flow: 'accessCode';
|
170 | scopes?: Oauth2Scopes;
|
171 | authorizationUrl: string;
|
172 | tokenUrl: string;
|
173 | description?: string;
|
174 | }
|
175 | interface Oauth2ApplicationSecurity {
|
176 | type: 'oauth2';
|
177 | flow: 'application';
|
178 | scopes?: Oauth2Scopes;
|
179 | tokenUrl: string;
|
180 | description?: string;
|
181 | }
|
182 | interface Oauth2ImplicitSecurity {
|
183 | type: 'oauth2';
|
184 | flow: 'implicit';
|
185 | scopes?: Oauth2Scopes;
|
186 | authorizationUrl: string;
|
187 | description?: string;
|
188 | }
|
189 | interface Oauth2PasswordSecurity {
|
190 | type: 'oauth2';
|
191 | flow: 'password';
|
192 | scopes?: Oauth2Scopes;
|
193 | tokenUrl: string;
|
194 | description?: string;
|
195 | }
|
196 | interface Oauth2Scopes {
|
197 | [name: string]: string;
|
198 | }
|
199 | interface Operation {
|
200 | tags?: string[];
|
201 | summary?: string;
|
202 | description?: string;
|
203 | externalDocs?: ExternalDocs;
|
204 | operationId?: string;
|
205 | produces?: MimeType[];
|
206 | consumes?: MimeType[];
|
207 | parameters?: ParametersList;
|
208 | responses: Responses;
|
209 | schemes?: SchemesList;
|
210 | deprecated?: boolean;
|
211 | security?: Security;
|
212 | }
|
213 | type Parameter = BodyParameter | NonBodyParameter;
|
214 | interface ParameterDefinitions {
|
215 | [name: string]: Parameter;
|
216 | }
|
217 | type ParametersList = Array<Parameter | JsonReference>;
|
218 | interface PathItem {
|
219 | $ref?: string;
|
220 | get?: Operation;
|
221 | put?: Operation;
|
222 | post?: Operation;
|
223 | delete?: Operation;
|
224 | options?: Operation;
|
225 | head?: Operation;
|
226 | patch?: Operation;
|
227 | parameters?: ParametersList;
|
228 | }
|
229 | interface PathParameterSubSchema {
|
230 | required: 'true';
|
231 | in?: 'path';
|
232 | description?: string;
|
233 | name?: string;
|
234 | type?: 'string' | 'number' | 'boolean' | 'integer' | 'array';
|
235 | format?: string;
|
236 | items?: PrimitivesItems;
|
237 | collectionFormat?: CollectionFormat;
|
238 | default?: Default;
|
239 | maximum?: Maximum;
|
240 | exclusiveMaximum?: ExclusiveMaximum;
|
241 | minimum?: Minimum;
|
242 | exclusiveMinimum?: ExclusiveMinimum;
|
243 | maxLength?: MaxLength;
|
244 | minLength?: MinLength;
|
245 | pattern?: Pattern;
|
246 | maxItems?: MaxItems;
|
247 | minItems?: MinItems;
|
248 | uniqueItems?: UniqueItems;
|
249 | enum?: Enum;
|
250 | multipleOf?: MultipleOf;
|
251 | }
|
252 | interface Paths {
|
253 | [path: string]: PathItem;
|
254 | }
|
255 | type Pattern = JsonSchemaOrg.Draft04.Schema.Properties.Pattern;
|
256 | interface PrimitivesItems {
|
257 | type?: 'string' | 'number' | 'integer' | 'boolean' | 'array';
|
258 | format?: string;
|
259 | items?: PrimitivesItems;
|
260 | collectionFormat?: CollectionFormat;
|
261 | default?: Default;
|
262 | maximum?: Maximum;
|
263 | exclusiveMaximum?: ExclusiveMaximum;
|
264 | minimum?: Minimum;
|
265 | exclusiveMinimum?: ExclusiveMinimum;
|
266 | maxLength?: MaxLength;
|
267 | minLength?: MinLength;
|
268 | pattern?: Pattern;
|
269 | maxItems?: MaxItems;
|
270 | minItems?: MinItems;
|
271 | uniqueItems?: UniqueItems;
|
272 | enum?: Enum;
|
273 | multipleOf?: MultipleOf;
|
274 | }
|
275 | interface QueryParameterSubSchema {
|
276 | required?: boolean;
|
277 | in?: 'query';
|
278 | description?: string;
|
279 | name?: string;
|
280 | allowEmptyValue?: boolean;
|
281 | type?: 'string' | 'number' | 'boolean' | 'integer' | 'array';
|
282 | format?: string;
|
283 | items?: PrimitivesItems;
|
284 | collectionFormat?: CollectionFormatWithMulti;
|
285 | default?: Default;
|
286 | maximum?: Maximum;
|
287 | exclusiveMaximum?: ExclusiveMaximum;
|
288 | minimum?: Minimum;
|
289 | exclusiveMinimum?: ExclusiveMinimum;
|
290 | maxLength?: MaxLength;
|
291 | minLength?: MinLength;
|
292 | pattern?: Pattern;
|
293 | maxItems?: MaxItems;
|
294 | minItems?: MinItems;
|
295 | uniqueItems?: UniqueItems;
|
296 | enum?: Enum;
|
297 | multipleOf?: MultipleOf;
|
298 | }
|
299 | interface Response {
|
300 | description: string;
|
301 | schema?: JsonSchemaOrg.Draft04.Schema | FileSchema;
|
302 | headers?: Headers;
|
303 | examples?: Examples;
|
304 | }
|
305 | interface ResponseDefinitions {
|
306 | [name: string]: Response;
|
307 | }
|
308 | type ResponseValue = Response | JsonReference;
|
309 | interface Responses {
|
310 | [name: string]: ResponseValue;
|
311 | }
|
312 | type SchemesList = Array<'http' | 'https' | 'ws' | 'wss'>;
|
313 | type Security = SecurityRequirement[];
|
314 | interface SecurityDefinitions {
|
315 | [name: string]: BasicAuthenticationSecurity | ApiKeySecurity | Oauth2ImplicitSecurity | Oauth2PasswordSecurity | Oauth2ApplicationSecurity | Oauth2AccessCodeSecurity;
|
316 | }
|
317 | interface SecurityRequirement {
|
318 | [name: string]: string[];
|
319 | }
|
320 | interface Tag {
|
321 | name: string;
|
322 | description?: string;
|
323 | externalDocs?: ExternalDocs;
|
324 | }
|
325 | type UniqueItems = JsonSchemaOrg.Draft04.Schema.Properties.UniqueItems;
|
326 | interface VendorExtension {
|
327 | [name: string]: any;
|
328 | }
|
329 | interface Xml {
|
330 | name?: string;
|
331 | namespace?: string;
|
332 | prefix?: string;
|
333 | attribute?: boolean;
|
334 | wrapped?: boolean;
|
335 | }
|
336 | }
|
337 | }
|
338 | }
|
339 | }
|