@mgrzmil-org/api-types 0.0.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.
Files changed (3) hide show
  1. package/openapi.json +575 -0
  2. package/package.json +13 -0
  3. package/src/api.ts +618 -0
package/openapi.json ADDED
@@ -0,0 +1,575 @@
1
+ {
2
+ "openapi": "3.1.0",
3
+ "info": {
4
+ "title": "dog-api",
5
+ "description": "API for accessing dog breed images and information",
6
+ "version": "1.0.0",
7
+ "contact": {
8
+ "name": "API Support"
9
+ }
10
+ },
11
+ "paths": {
12
+ "/breeds/list/all": {
13
+ "get": {
14
+ "tags": [
15
+ "Breeds"
16
+ ],
17
+ "summary": "List all breeds",
18
+ "description": "Returns a list of all available dog breeds and their sub-breeds",
19
+ "operationId": "list_all_breeds_breeds_list_all_get",
20
+ "responses": {
21
+ "200": {
22
+ "description": "Successful Response",
23
+ "content": {
24
+ "application/json": {
25
+ "schema": {
26
+ "$ref": "#/components/schemas/APIResponse"
27
+ }
28
+ }
29
+ }
30
+ }
31
+ }
32
+ }
33
+ },
34
+ "/breed/{breed}/list": {
35
+ "get": {
36
+ "tags": [
37
+ "Breeds"
38
+ ],
39
+ "summary": "Get breed sub-breeds",
40
+ "description": "Returns a list of sub-breeds for a specific breed -",
41
+ "operationId": "breed_subbreeds_breed__breed__list_get",
42
+ "parameters": [
43
+ {
44
+ "name": "breed",
45
+ "in": "path",
46
+ "required": true,
47
+ "schema": {
48
+ "type": "string",
49
+ "title": "Breed"
50
+ }
51
+ }
52
+ ],
53
+ "responses": {
54
+ "200": {
55
+ "description": "Successful Response",
56
+ "content": {
57
+ "application/json": {
58
+ "schema": {
59
+ "$ref": "#/components/schemas/APIResponse"
60
+ }
61
+ }
62
+ }
63
+ },
64
+ "422": {
65
+ "description": "Validation Error",
66
+ "content": {
67
+ "application/json": {
68
+ "schema": {
69
+ "$ref": "#/components/schemas/HTTPValidationError"
70
+ }
71
+ }
72
+ }
73
+ }
74
+ }
75
+ }
76
+ },
77
+ "/breeds/image/random": {
78
+ "get": {
79
+ "tags": [
80
+ "Images"
81
+ ],
82
+ "summary": "Get random image",
83
+ "description": "Returns a random dog image URL from all available breeds",
84
+ "operationId": "random_image_breeds_image_random_get",
85
+ "responses": {
86
+ "200": {
87
+ "description": "Successful Response",
88
+ "content": {
89
+ "application/json": {
90
+ "schema": {
91
+ "$ref": "#/components/schemas/APIResponse"
92
+ }
93
+ }
94
+ }
95
+ }
96
+ }
97
+ }
98
+ },
99
+ "/breed/{breed}/images": {
100
+ "get": {
101
+ "tags": [
102
+ "Images"
103
+ ],
104
+ "summary": "Get breed images",
105
+ "description": "Returns all image URLs for a specific breed",
106
+ "operationId": "breed_images_breed__breed__images_get",
107
+ "parameters": [
108
+ {
109
+ "name": "breed",
110
+ "in": "path",
111
+ "required": true,
112
+ "schema": {
113
+ "type": "string",
114
+ "title": "Breed"
115
+ }
116
+ }
117
+ ],
118
+ "responses": {
119
+ "200": {
120
+ "description": "Successful Response",
121
+ "content": {
122
+ "application/json": {
123
+ "schema": {
124
+ "$ref": "#/components/schemas/APIResponse"
125
+ }
126
+ }
127
+ }
128
+ },
129
+ "422": {
130
+ "description": "Validation Error",
131
+ "content": {
132
+ "application/json": {
133
+ "schema": {
134
+ "$ref": "#/components/schemas/HTTPValidationError"
135
+ }
136
+ }
137
+ }
138
+ }
139
+ }
140
+ }
141
+ },
142
+ "/breed/{breed}/images/random": {
143
+ "get": {
144
+ "tags": [
145
+ "Images"
146
+ ],
147
+ "summary": "Get random breed image",
148
+ "description": "Returns a random image URL for a specific breed",
149
+ "operationId": "random_breed_image_breed__breed__images_random_get",
150
+ "parameters": [
151
+ {
152
+ "name": "breed",
153
+ "in": "path",
154
+ "required": true,
155
+ "schema": {
156
+ "type": "string",
157
+ "title": "Breed"
158
+ }
159
+ }
160
+ ],
161
+ "responses": {
162
+ "200": {
163
+ "description": "Successful Response",
164
+ "content": {
165
+ "application/json": {
166
+ "schema": {
167
+ "$ref": "#/components/schemas/APIResponse"
168
+ }
169
+ }
170
+ }
171
+ },
172
+ "422": {
173
+ "description": "Validation Error",
174
+ "content": {
175
+ "application/json": {
176
+ "schema": {
177
+ "$ref": "#/components/schemas/HTTPValidationError"
178
+ }
179
+ }
180
+ }
181
+ }
182
+ }
183
+ }
184
+ },
185
+ "/breed/{breed}/{subbreed}/images": {
186
+ "get": {
187
+ "tags": [
188
+ "Images"
189
+ ],
190
+ "summary": "Get sub-breed images",
191
+ "description": "Returns all image URLs for a specific sub-breed",
192
+ "operationId": "subbreed_images_breed__breed___subbreed__images_get",
193
+ "parameters": [
194
+ {
195
+ "name": "breed",
196
+ "in": "path",
197
+ "required": true,
198
+ "schema": {
199
+ "type": "string",
200
+ "title": "Breed"
201
+ }
202
+ },
203
+ {
204
+ "name": "subbreed",
205
+ "in": "path",
206
+ "required": true,
207
+ "schema": {
208
+ "type": "string",
209
+ "title": "Subbreed"
210
+ }
211
+ }
212
+ ],
213
+ "responses": {
214
+ "200": {
215
+ "description": "Successful Response",
216
+ "content": {
217
+ "application/json": {
218
+ "schema": {
219
+ "$ref": "#/components/schemas/APIResponse"
220
+ }
221
+ }
222
+ }
223
+ },
224
+ "422": {
225
+ "description": "Validation Error",
226
+ "content": {
227
+ "application/json": {
228
+ "schema": {
229
+ "$ref": "#/components/schemas/HTTPValidationError"
230
+ }
231
+ }
232
+ }
233
+ }
234
+ }
235
+ }
236
+ },
237
+ "/breed/{breed}/{subbreed}/images/random": {
238
+ "get": {
239
+ "tags": [
240
+ "Images"
241
+ ],
242
+ "summary": "Get random sub-breed image",
243
+ "description": "Returns a random image URL for a specific sub-breed",
244
+ "operationId": "random_subbreed_image_breed__breed___subbreed__images_random_get",
245
+ "parameters": [
246
+ {
247
+ "name": "breed",
248
+ "in": "path",
249
+ "required": true,
250
+ "schema": {
251
+ "type": "string",
252
+ "title": "Breed"
253
+ }
254
+ },
255
+ {
256
+ "name": "subbreed",
257
+ "in": "path",
258
+ "required": true,
259
+ "schema": {
260
+ "type": "string",
261
+ "title": "Subbreed"
262
+ }
263
+ }
264
+ ],
265
+ "responses": {
266
+ "200": {
267
+ "description": "Successful Response",
268
+ "content": {
269
+ "application/json": {
270
+ "schema": {
271
+ "$ref": "#/components/schemas/APIResponse"
272
+ }
273
+ }
274
+ }
275
+ },
276
+ "422": {
277
+ "description": "Validation Error",
278
+ "content": {
279
+ "application/json": {
280
+ "schema": {
281
+ "$ref": "#/components/schemas/HTTPValidationError"
282
+ }
283
+ }
284
+ }
285
+ }
286
+ }
287
+ }
288
+ },
289
+ "/images/{file_path}": {
290
+ "get": {
291
+ "tags": [
292
+ "Images"
293
+ ],
294
+ "summary": "Serve image file",
295
+ "description": "Serves the actual image file by path",
296
+ "operationId": "serve_image_images__file_path__get",
297
+ "parameters": [
298
+ {
299
+ "name": "file_path",
300
+ "in": "path",
301
+ "required": true,
302
+ "schema": {
303
+ "type": "string",
304
+ "title": "File Path"
305
+ }
306
+ }
307
+ ],
308
+ "responses": {
309
+ "200": {
310
+ "description": "Successful Response",
311
+ "content": {
312
+ "application/json": {
313
+ "schema": {}
314
+ }
315
+ }
316
+ },
317
+ "422": {
318
+ "description": "Validation Error",
319
+ "content": {
320
+ "application/json": {
321
+ "schema": {
322
+ "$ref": "#/components/schemas/HTTPValidationError"
323
+ }
324
+ }
325
+ }
326
+ }
327
+ }
328
+ }
329
+ },
330
+ "/performance": {
331
+ "get": {
332
+ "tags": [
333
+ "health"
334
+ ],
335
+ "summary": "check api os performance",
336
+ "description": "check api os performance cpu, memory, disk",
337
+ "operationId": "system_performance_performance_get",
338
+ "responses": {
339
+ "200": {
340
+ "description": "Successful Response",
341
+ "content": {
342
+ "application/json": {
343
+ "schema": {
344
+ "$ref": "#/components/schemas/APIResponse"
345
+ }
346
+ }
347
+ }
348
+ }
349
+ }
350
+ }
351
+ },
352
+ "/healthcheck": {
353
+ "get": {
354
+ "tags": [
355
+ "health"
356
+ ],
357
+ "summary": "check api health",
358
+ "description": "check api health, returns ok 200 if healthy",
359
+ "operationId": "system_health_healthcheck_get",
360
+ "responses": {
361
+ "200": {
362
+ "description": "Successful Response",
363
+ "content": {
364
+ "application/json": {
365
+ "schema": {
366
+ "$ref": "#/components/schemas/APIResponse"
367
+ }
368
+ }
369
+ }
370
+ }
371
+ }
372
+ }
373
+ },
374
+ "/breed/{breed}/description": {
375
+ "get": {
376
+ "tags": [
377
+ "Descriptions"
378
+ ],
379
+ "summary": "Get breed description",
380
+ "description": "Returns the description for a specific breed in multiple languages",
381
+ "operationId": "breed_description_breed__breed__description_get",
382
+ "parameters": [
383
+ {
384
+ "name": "breed",
385
+ "in": "path",
386
+ "required": true,
387
+ "schema": {
388
+ "type": "string",
389
+ "title": "Breed"
390
+ }
391
+ }
392
+ ],
393
+ "responses": {
394
+ "200": {
395
+ "description": "Successful Response",
396
+ "content": {
397
+ "application/json": {
398
+ "schema": {
399
+ "$ref": "#/components/schemas/APIResponse"
400
+ }
401
+ }
402
+ }
403
+ },
404
+ "422": {
405
+ "description": "Validation Error",
406
+ "content": {
407
+ "application/json": {
408
+ "schema": {
409
+ "$ref": "#/components/schemas/HTTPValidationError"
410
+ }
411
+ }
412
+ }
413
+ }
414
+ }
415
+ }
416
+ },
417
+ "/breed/{breed}/{variant}/description": {
418
+ "get": {
419
+ "tags": [
420
+ "Descriptions"
421
+ ],
422
+ "summary": "Get variant description",
423
+ "description": "Returns the description for a specific breed variant in multiple languages",
424
+ "operationId": "variant_description_breed__breed___variant__description_get",
425
+ "parameters": [
426
+ {
427
+ "name": "breed",
428
+ "in": "path",
429
+ "required": true,
430
+ "schema": {
431
+ "type": "string",
432
+ "title": "Breed"
433
+ }
434
+ },
435
+ {
436
+ "name": "variant",
437
+ "in": "path",
438
+ "required": true,
439
+ "schema": {
440
+ "type": "string",
441
+ "title": "Variant"
442
+ }
443
+ }
444
+ ],
445
+ "responses": {
446
+ "200": {
447
+ "description": "Successful Response",
448
+ "content": {
449
+ "application/json": {
450
+ "schema": {
451
+ "$ref": "#/components/schemas/APIResponse"
452
+ }
453
+ }
454
+ }
455
+ },
456
+ "422": {
457
+ "description": "Validation Error",
458
+ "content": {
459
+ "application/json": {
460
+ "schema": {
461
+ "$ref": "#/components/schemas/HTTPValidationError"
462
+ }
463
+ }
464
+ }
465
+ }
466
+ }
467
+ }
468
+ }
469
+ },
470
+ "components": {
471
+ "schemas": {
472
+ "APIResponse": {
473
+ "properties": {
474
+ "status": {
475
+ "$ref": "#/components/schemas/Status"
476
+ },
477
+ "message": {
478
+ "anyOf": [
479
+ {
480
+ "additionalProperties": true,
481
+ "type": "object"
482
+ },
483
+ {
484
+ "items": {
485
+ "type": "string"
486
+ },
487
+ "type": "array"
488
+ },
489
+ {
490
+ "type": "string"
491
+ }
492
+ ],
493
+ "title": "Message"
494
+ }
495
+ },
496
+ "type": "object",
497
+ "required": [
498
+ "status",
499
+ "message"
500
+ ],
501
+ "title": "APIResponse"
502
+ },
503
+ "HTTPValidationError": {
504
+ "properties": {
505
+ "detail": {
506
+ "items": {
507
+ "$ref": "#/components/schemas/ValidationError"
508
+ },
509
+ "type": "array",
510
+ "title": "Detail"
511
+ }
512
+ },
513
+ "type": "object",
514
+ "title": "HTTPValidationError"
515
+ },
516
+ "Status": {
517
+ "type": "string",
518
+ "enum": [
519
+ "success",
520
+ "error"
521
+ ],
522
+ "title": "Status"
523
+ },
524
+ "ValidationError": {
525
+ "properties": {
526
+ "loc": {
527
+ "items": {
528
+ "anyOf": [
529
+ {
530
+ "type": "string"
531
+ },
532
+ {
533
+ "type": "integer"
534
+ }
535
+ ]
536
+ },
537
+ "type": "array",
538
+ "title": "Location"
539
+ },
540
+ "msg": {
541
+ "type": "string",
542
+ "title": "Message"
543
+ },
544
+ "type": {
545
+ "type": "string",
546
+ "title": "Error Type"
547
+ }
548
+ },
549
+ "type": "object",
550
+ "required": [
551
+ "loc",
552
+ "msg",
553
+ "type"
554
+ ],
555
+ "title": "ValidationError"
556
+ }
557
+ }
558
+ },
559
+ "tags": [
560
+ {
561
+ "name": "Breeds",
562
+ "description": "Operations related to dog breeds and sub-breeds"
563
+ },
564
+ {
565
+ "name": "Images",
566
+ "description": "Operations related to dog images"
567
+ }
568
+ ],
569
+ "servers": [
570
+ {
571
+ "url": "http://localhost:8000",
572
+ "description": "Local development server"
573
+ }
574
+ ]
575
+ }
package/package.json ADDED
@@ -0,0 +1,13 @@
1
+ {
2
+ "name": "@mgrzmil-org/api-types",
3
+ "version": "0.0.0",
4
+ "description": "Generated TypeScript types + OpenAPI spec for dog-api",
5
+ "files": [
6
+ "src/api.ts",
7
+ "openapi.json"
8
+ ],
9
+ "types": "src/api.ts",
10
+ "publishConfig": {
11
+ "access": "public"
12
+ }
13
+ }
package/src/api.ts ADDED
@@ -0,0 +1,618 @@
1
+ /**
2
+ * This file was auto-generated by openapi-typescript.
3
+ * Do not make direct changes to the file.
4
+ */
5
+
6
+ export interface paths {
7
+ "/breeds/list/all": {
8
+ parameters: {
9
+ query?: never;
10
+ header?: never;
11
+ path?: never;
12
+ cookie?: never;
13
+ };
14
+ /**
15
+ * List all breeds
16
+ * @description Returns a list of all available dog breeds and their sub-breeds
17
+ */
18
+ get: operations["list_all_breeds_breeds_list_all_get"];
19
+ put?: never;
20
+ post?: never;
21
+ delete?: never;
22
+ options?: never;
23
+ head?: never;
24
+ patch?: never;
25
+ trace?: never;
26
+ };
27
+ "/breed/{breed}/list": {
28
+ parameters: {
29
+ query?: never;
30
+ header?: never;
31
+ path?: never;
32
+ cookie?: never;
33
+ };
34
+ /**
35
+ * Get breed sub-breeds
36
+ * @description Returns a list of sub-breeds for a specific breed -
37
+ */
38
+ get: operations["breed_subbreeds_breed__breed__list_get"];
39
+ put?: never;
40
+ post?: never;
41
+ delete?: never;
42
+ options?: never;
43
+ head?: never;
44
+ patch?: never;
45
+ trace?: never;
46
+ };
47
+ "/breeds/image/random": {
48
+ parameters: {
49
+ query?: never;
50
+ header?: never;
51
+ path?: never;
52
+ cookie?: never;
53
+ };
54
+ /**
55
+ * Get random image
56
+ * @description Returns a random dog image URL from all available breeds
57
+ */
58
+ get: operations["random_image_breeds_image_random_get"];
59
+ put?: never;
60
+ post?: never;
61
+ delete?: never;
62
+ options?: never;
63
+ head?: never;
64
+ patch?: never;
65
+ trace?: never;
66
+ };
67
+ "/breed/{breed}/images": {
68
+ parameters: {
69
+ query?: never;
70
+ header?: never;
71
+ path?: never;
72
+ cookie?: never;
73
+ };
74
+ /**
75
+ * Get breed images
76
+ * @description Returns all image URLs for a specific breed
77
+ */
78
+ get: operations["breed_images_breed__breed__images_get"];
79
+ put?: never;
80
+ post?: never;
81
+ delete?: never;
82
+ options?: never;
83
+ head?: never;
84
+ patch?: never;
85
+ trace?: never;
86
+ };
87
+ "/breed/{breed}/images/random": {
88
+ parameters: {
89
+ query?: never;
90
+ header?: never;
91
+ path?: never;
92
+ cookie?: never;
93
+ };
94
+ /**
95
+ * Get random breed image
96
+ * @description Returns a random image URL for a specific breed
97
+ */
98
+ get: operations["random_breed_image_breed__breed__images_random_get"];
99
+ put?: never;
100
+ post?: never;
101
+ delete?: never;
102
+ options?: never;
103
+ head?: never;
104
+ patch?: never;
105
+ trace?: never;
106
+ };
107
+ "/breed/{breed}/{subbreed}/images": {
108
+ parameters: {
109
+ query?: never;
110
+ header?: never;
111
+ path?: never;
112
+ cookie?: never;
113
+ };
114
+ /**
115
+ * Get sub-breed images
116
+ * @description Returns all image URLs for a specific sub-breed
117
+ */
118
+ get: operations["subbreed_images_breed__breed___subbreed__images_get"];
119
+ put?: never;
120
+ post?: never;
121
+ delete?: never;
122
+ options?: never;
123
+ head?: never;
124
+ patch?: never;
125
+ trace?: never;
126
+ };
127
+ "/breed/{breed}/{subbreed}/images/random": {
128
+ parameters: {
129
+ query?: never;
130
+ header?: never;
131
+ path?: never;
132
+ cookie?: never;
133
+ };
134
+ /**
135
+ * Get random sub-breed image
136
+ * @description Returns a random image URL for a specific sub-breed
137
+ */
138
+ get: operations["random_subbreed_image_breed__breed___subbreed__images_random_get"];
139
+ put?: never;
140
+ post?: never;
141
+ delete?: never;
142
+ options?: never;
143
+ head?: never;
144
+ patch?: never;
145
+ trace?: never;
146
+ };
147
+ "/images/{file_path}": {
148
+ parameters: {
149
+ query?: never;
150
+ header?: never;
151
+ path?: never;
152
+ cookie?: never;
153
+ };
154
+ /**
155
+ * Serve image file
156
+ * @description Serves the actual image file by path
157
+ */
158
+ get: operations["serve_image_images__file_path__get"];
159
+ put?: never;
160
+ post?: never;
161
+ delete?: never;
162
+ options?: never;
163
+ head?: never;
164
+ patch?: never;
165
+ trace?: never;
166
+ };
167
+ "/performance": {
168
+ parameters: {
169
+ query?: never;
170
+ header?: never;
171
+ path?: never;
172
+ cookie?: never;
173
+ };
174
+ /**
175
+ * check api os performance
176
+ * @description check api os performance cpu, memory, disk
177
+ */
178
+ get: operations["system_performance_performance_get"];
179
+ put?: never;
180
+ post?: never;
181
+ delete?: never;
182
+ options?: never;
183
+ head?: never;
184
+ patch?: never;
185
+ trace?: never;
186
+ };
187
+ "/healthcheck": {
188
+ parameters: {
189
+ query?: never;
190
+ header?: never;
191
+ path?: never;
192
+ cookie?: never;
193
+ };
194
+ /**
195
+ * check api health
196
+ * @description check api health, returns ok 200 if healthy
197
+ */
198
+ get: operations["system_health_healthcheck_get"];
199
+ put?: never;
200
+ post?: never;
201
+ delete?: never;
202
+ options?: never;
203
+ head?: never;
204
+ patch?: never;
205
+ trace?: never;
206
+ };
207
+ "/breed/{breed}/description": {
208
+ parameters: {
209
+ query?: never;
210
+ header?: never;
211
+ path?: never;
212
+ cookie?: never;
213
+ };
214
+ /**
215
+ * Get breed description
216
+ * @description Returns the description for a specific breed in multiple languages
217
+ */
218
+ get: operations["breed_description_breed__breed__description_get"];
219
+ put?: never;
220
+ post?: never;
221
+ delete?: never;
222
+ options?: never;
223
+ head?: never;
224
+ patch?: never;
225
+ trace?: never;
226
+ };
227
+ "/breed/{breed}/{variant}/description": {
228
+ parameters: {
229
+ query?: never;
230
+ header?: never;
231
+ path?: never;
232
+ cookie?: never;
233
+ };
234
+ /**
235
+ * Get variant description
236
+ * @description Returns the description for a specific breed variant in multiple languages
237
+ */
238
+ get: operations["variant_description_breed__breed___variant__description_get"];
239
+ put?: never;
240
+ post?: never;
241
+ delete?: never;
242
+ options?: never;
243
+ head?: never;
244
+ patch?: never;
245
+ trace?: never;
246
+ };
247
+ }
248
+ export type webhooks = Record<string, never>;
249
+ export interface components {
250
+ schemas: {
251
+ /** APIResponse */
252
+ APIResponse: {
253
+ status: components["schemas"]["Status"];
254
+ /** Message */
255
+ message: {
256
+ [key: string]: unknown;
257
+ } | string[] | string;
258
+ };
259
+ /** HTTPValidationError */
260
+ HTTPValidationError: {
261
+ /** Detail */
262
+ detail?: components["schemas"]["ValidationError"][];
263
+ };
264
+ /**
265
+ * Status
266
+ * @enum {string}
267
+ */
268
+ Status: "success" | "error";
269
+ /** ValidationError */
270
+ ValidationError: {
271
+ /** Location */
272
+ loc: (string | number)[];
273
+ /** Message */
274
+ msg: string;
275
+ /** Error Type */
276
+ type: string;
277
+ };
278
+ };
279
+ responses: never;
280
+ parameters: never;
281
+ requestBodies: never;
282
+ headers: never;
283
+ pathItems: never;
284
+ }
285
+ export type $defs = Record<string, never>;
286
+ export interface operations {
287
+ list_all_breeds_breeds_list_all_get: {
288
+ parameters: {
289
+ query?: never;
290
+ header?: never;
291
+ path?: never;
292
+ cookie?: never;
293
+ };
294
+ requestBody?: never;
295
+ responses: {
296
+ /** @description Successful Response */
297
+ 200: {
298
+ headers: {
299
+ [name: string]: unknown;
300
+ };
301
+ content: {
302
+ "application/json": components["schemas"]["APIResponse"];
303
+ };
304
+ };
305
+ };
306
+ };
307
+ breed_subbreeds_breed__breed__list_get: {
308
+ parameters: {
309
+ query?: never;
310
+ header?: never;
311
+ path: {
312
+ breed: string;
313
+ };
314
+ cookie?: never;
315
+ };
316
+ requestBody?: never;
317
+ responses: {
318
+ /** @description Successful Response */
319
+ 200: {
320
+ headers: {
321
+ [name: string]: unknown;
322
+ };
323
+ content: {
324
+ "application/json": components["schemas"]["APIResponse"];
325
+ };
326
+ };
327
+ /** @description Validation Error */
328
+ 422: {
329
+ headers: {
330
+ [name: string]: unknown;
331
+ };
332
+ content: {
333
+ "application/json": components["schemas"]["HTTPValidationError"];
334
+ };
335
+ };
336
+ };
337
+ };
338
+ random_image_breeds_image_random_get: {
339
+ parameters: {
340
+ query?: never;
341
+ header?: never;
342
+ path?: never;
343
+ cookie?: never;
344
+ };
345
+ requestBody?: never;
346
+ responses: {
347
+ /** @description Successful Response */
348
+ 200: {
349
+ headers: {
350
+ [name: string]: unknown;
351
+ };
352
+ content: {
353
+ "application/json": components["schemas"]["APIResponse"];
354
+ };
355
+ };
356
+ };
357
+ };
358
+ breed_images_breed__breed__images_get: {
359
+ parameters: {
360
+ query?: never;
361
+ header?: never;
362
+ path: {
363
+ breed: string;
364
+ };
365
+ cookie?: never;
366
+ };
367
+ requestBody?: never;
368
+ responses: {
369
+ /** @description Successful Response */
370
+ 200: {
371
+ headers: {
372
+ [name: string]: unknown;
373
+ };
374
+ content: {
375
+ "application/json": components["schemas"]["APIResponse"];
376
+ };
377
+ };
378
+ /** @description Validation Error */
379
+ 422: {
380
+ headers: {
381
+ [name: string]: unknown;
382
+ };
383
+ content: {
384
+ "application/json": components["schemas"]["HTTPValidationError"];
385
+ };
386
+ };
387
+ };
388
+ };
389
+ random_breed_image_breed__breed__images_random_get: {
390
+ parameters: {
391
+ query?: never;
392
+ header?: never;
393
+ path: {
394
+ breed: string;
395
+ };
396
+ cookie?: never;
397
+ };
398
+ requestBody?: never;
399
+ responses: {
400
+ /** @description Successful Response */
401
+ 200: {
402
+ headers: {
403
+ [name: string]: unknown;
404
+ };
405
+ content: {
406
+ "application/json": components["schemas"]["APIResponse"];
407
+ };
408
+ };
409
+ /** @description Validation Error */
410
+ 422: {
411
+ headers: {
412
+ [name: string]: unknown;
413
+ };
414
+ content: {
415
+ "application/json": components["schemas"]["HTTPValidationError"];
416
+ };
417
+ };
418
+ };
419
+ };
420
+ subbreed_images_breed__breed___subbreed__images_get: {
421
+ parameters: {
422
+ query?: never;
423
+ header?: never;
424
+ path: {
425
+ breed: string;
426
+ subbreed: string;
427
+ };
428
+ cookie?: never;
429
+ };
430
+ requestBody?: never;
431
+ responses: {
432
+ /** @description Successful Response */
433
+ 200: {
434
+ headers: {
435
+ [name: string]: unknown;
436
+ };
437
+ content: {
438
+ "application/json": components["schemas"]["APIResponse"];
439
+ };
440
+ };
441
+ /** @description Validation Error */
442
+ 422: {
443
+ headers: {
444
+ [name: string]: unknown;
445
+ };
446
+ content: {
447
+ "application/json": components["schemas"]["HTTPValidationError"];
448
+ };
449
+ };
450
+ };
451
+ };
452
+ random_subbreed_image_breed__breed___subbreed__images_random_get: {
453
+ parameters: {
454
+ query?: never;
455
+ header?: never;
456
+ path: {
457
+ breed: string;
458
+ subbreed: string;
459
+ };
460
+ cookie?: never;
461
+ };
462
+ requestBody?: never;
463
+ responses: {
464
+ /** @description Successful Response */
465
+ 200: {
466
+ headers: {
467
+ [name: string]: unknown;
468
+ };
469
+ content: {
470
+ "application/json": components["schemas"]["APIResponse"];
471
+ };
472
+ };
473
+ /** @description Validation Error */
474
+ 422: {
475
+ headers: {
476
+ [name: string]: unknown;
477
+ };
478
+ content: {
479
+ "application/json": components["schemas"]["HTTPValidationError"];
480
+ };
481
+ };
482
+ };
483
+ };
484
+ serve_image_images__file_path__get: {
485
+ parameters: {
486
+ query?: never;
487
+ header?: never;
488
+ path: {
489
+ file_path: string;
490
+ };
491
+ cookie?: never;
492
+ };
493
+ requestBody?: never;
494
+ responses: {
495
+ /** @description Successful Response */
496
+ 200: {
497
+ headers: {
498
+ [name: string]: unknown;
499
+ };
500
+ content: {
501
+ "application/json": unknown;
502
+ };
503
+ };
504
+ /** @description Validation Error */
505
+ 422: {
506
+ headers: {
507
+ [name: string]: unknown;
508
+ };
509
+ content: {
510
+ "application/json": components["schemas"]["HTTPValidationError"];
511
+ };
512
+ };
513
+ };
514
+ };
515
+ system_performance_performance_get: {
516
+ parameters: {
517
+ query?: never;
518
+ header?: never;
519
+ path?: never;
520
+ cookie?: never;
521
+ };
522
+ requestBody?: never;
523
+ responses: {
524
+ /** @description Successful Response */
525
+ 200: {
526
+ headers: {
527
+ [name: string]: unknown;
528
+ };
529
+ content: {
530
+ "application/json": components["schemas"]["APIResponse"];
531
+ };
532
+ };
533
+ };
534
+ };
535
+ system_health_healthcheck_get: {
536
+ parameters: {
537
+ query?: never;
538
+ header?: never;
539
+ path?: never;
540
+ cookie?: never;
541
+ };
542
+ requestBody?: never;
543
+ responses: {
544
+ /** @description Successful Response */
545
+ 200: {
546
+ headers: {
547
+ [name: string]: unknown;
548
+ };
549
+ content: {
550
+ "application/json": components["schemas"]["APIResponse"];
551
+ };
552
+ };
553
+ };
554
+ };
555
+ breed_description_breed__breed__description_get: {
556
+ parameters: {
557
+ query?: never;
558
+ header?: never;
559
+ path: {
560
+ breed: string;
561
+ };
562
+ cookie?: never;
563
+ };
564
+ requestBody?: never;
565
+ responses: {
566
+ /** @description Successful Response */
567
+ 200: {
568
+ headers: {
569
+ [name: string]: unknown;
570
+ };
571
+ content: {
572
+ "application/json": components["schemas"]["APIResponse"];
573
+ };
574
+ };
575
+ /** @description Validation Error */
576
+ 422: {
577
+ headers: {
578
+ [name: string]: unknown;
579
+ };
580
+ content: {
581
+ "application/json": components["schemas"]["HTTPValidationError"];
582
+ };
583
+ };
584
+ };
585
+ };
586
+ variant_description_breed__breed___variant__description_get: {
587
+ parameters: {
588
+ query?: never;
589
+ header?: never;
590
+ path: {
591
+ breed: string;
592
+ variant: string;
593
+ };
594
+ cookie?: never;
595
+ };
596
+ requestBody?: never;
597
+ responses: {
598
+ /** @description Successful Response */
599
+ 200: {
600
+ headers: {
601
+ [name: string]: unknown;
602
+ };
603
+ content: {
604
+ "application/json": components["schemas"]["APIResponse"];
605
+ };
606
+ };
607
+ /** @description Validation Error */
608
+ 422: {
609
+ headers: {
610
+ [name: string]: unknown;
611
+ };
612
+ content: {
613
+ "application/json": components["schemas"]["HTTPValidationError"];
614
+ };
615
+ };
616
+ };
617
+ };
618
+ }