github.com/Tyktechnologies/tyk@v2.9.5+incompatible/swagger.yml (about) 1 openapi: 3.0.0 2 info: 3 title: Tyk Gateway API 4 version: 2.8.0 5 description: |- 6 The Tyk Gateway REST API is the primary means for integrating your application with the Tyk API Gateway system. This API is very small, and has no granular permissions system. It is intended to be used purely for internal automation and integration. 7 8 **Warning: Under no circumstances should outside parties be granted access to this API.** 9 10 The Tyk Gateway API is capable of: 11 12 * Managing session objects (key generation) 13 * Managing and listing policies 14 * Managing and listing API Definitions (only when not using the Dashboard) 15 * Hot reloads / reloading a cluster configuration 16 * OAuth client creation (only when not using the Dashboard) 17 18 19 In order to use the REST API, you'll need to set the `secret` parameter in your tyk.conf file. 20 21 The shared secret you set should then be sent along as a header with each REST API Request in order for it to be successful: 22 23 ``` 24 x-tyk-authorization: <your-secret> 25 ``` 26 <br/> 27 <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> 28 servers: 29 - url: 'http://localhost/' 30 - url: 'https://localhost/' 31 tags: 32 - name: Keys 33 description: |- 34 All keys that are used to access services via Tyk correspond to a session object that informs Tyk about the context of this particular token, like access rules and rate/quota allowance. 35 36 <h3>Hashed Keys Environment</h3> 37 38 Listing tokens is only possible if you set `enable_hashed_keys_listing` to `true`. See [Using Hashed Keys Environment Endpoints](https://tyk.io/docs/security/#a-name-key-hashing-a-key-hashing) section for more details. 39 40 - endpoints `POST /tyk/keys/create`, `POST /tyk/keys` and `POST /tyk/keys/{keyName}` return `"key_hash"` for future use. 41 - endpoint `GET /tyk/keys` retrieves all (or per API) key hashes. You can disable this endpoint by using the `tyk.conf` setting `enable_hashed_keys_listing` (set to false by default). 42 - endpoint `GET /tyk/keys/{keyName}` is able to get a key by its hash. You need to provide the key hash as a `keyName`. 43 and call it with the optional query parameter `hashed=true`. So the format is `GET /tyk/keys/{keyName}?hashed=true"`. 44 - The same optional parameter is available for the `DELETE /tyk/keys/{keyName}?hashed=true` endpoint. 45 46 <h3>Example: Import Existing Keys into Tyk</h3> 47 48 49 50 You can use the `PUT /tyk/keys/{KEY_ID}` endpoint as defined below to import existing keys into Tyk. 51 52 This example uses standard `authorization` header authentication, and assumes that the Dashboard is located at `127.0.0.1:8080` and the Tyk secret is `352d20ee67be67f6340b4c0605b044b7` - update these as necessary to match your environment. 53 54 To import a key called `abc`, save the JSON contents as `token.json` (see example below), then run the following Curl command. 55 56 ``` 57 curl http://127.0.0.1:8080/tyk/keys/abc -H 'x-tyk-authorization: 352d20ee67be67f6340b4c0605b044b7' -H 'Content-Type: application/json' -d @token.json 58 ``` 59 60 The following request will fail as the key doesn't exist. 61 62 ``` 63 curl http://127.0.0.1:8080/quickstart/headers -H 'Authorization. invalid123' 64 ``` 65 66 But this request will now work, using the imported key. 67 68 ``` 69 curl http://127.0.0.1:8080/quickstart/headers -H 'Authorization: abc' 70 ``` 71 72 <h4>Example token.json file<h4> 73 74 ``` 75 { 76 "allowance": 1000, 77 "rate": 1000, 78 "per": 60, 79 "expires": -1, 80 "quota_max": -1, 81 "quota_renews": 1406121006, 82 "quota_remaining": 0, 83 "quota_renewal_rate": 60, 84 "access_rights": { 85 "3": { 86 "api_name": "Tyk Test API", 87 "api_id": "3" 88 } 89 }, 90 "org_id": "53ac07777cbb8c2d53000002", 91 "basic_auth_data": { 92 "password": "", 93 "hash_type": "" 94 }, 95 "hmac_enabled": false, 96 "hmac_string": "", 97 "is_inactive": false, 98 "apply_policy_id": "", 99 "apply_policies": [ 100 "59672779fa4387000129507d", 101 "53222349fa4387004324324e", 102 "543534s9fa4387004324324d" 103 ], 104 "monitor": { 105 "trigger_limits": [] 106 } 107 } 108 ``` 109 110 Additionally see <a href="https://tyk.io/docs/tyk-rest-api/token-session-object-details/">key session object data format</a>. 111 - name: OAuth 112 description: |- 113 Manage OAuth clients, and manage their tokens 114 - name: Cache Invalidation 115 description: |- 116 Sometimes a cache might contain stale data, or it may just need to be cleared because of an invalid configuration. This call will purge all keys associated with a cache on an API-by-API basis. 117 - name: Hot Reload 118 description: 119 Force restart of the Gateway or whole cluster 120 - name: Health Checking 121 description: Check health check of the Gateway and loaded APIs 122 - name: Organisation Quotas 123 description: |- 124 It is possible to force API quota and rate limit across all keys that belong to a specific organisation ID. Rate limiting at an organisation level is useful for creating tiered access levels and trial accounts. 125 The Organisation rate limiting middleware works with both Quotas and Rate Limiters. In order to manage this functionality, a simple API has been put in place to manage these sessions. 126 Although the Organisation session-limiter uses the same session object, all other security keys are optional as they are not used. 127 128 <h3>Managing active status</h3> 129 To disallow access to an entire group of keys without rate limiting the organisation, create a session object with the "is_inactive" key set to true. This will block access before any other middleware is executed. It is useful when managing subscriptions for an organisation group and access needs to be blocked because of non-payment. 130 - name: Batch requests 131 description: |- 132 Tyk supports batch requests, so a client makes a single request to the API but gets a compound response object back. 133 134 This is especially handy if clients have complex requests that have multiple synchronous dependencies and do not wish to have the entire request / response cycle running for each event. 135 136 To enable batch request support, set the `enable_batch_request_support` value to `true` 137 138 This is especially handy if clients have complex requests that have multiple synchronous dependencies and do not wish to have the entire request / response cycle running for each event. 139 140 Batch requests that come into Tyk are *run through the whole Tyk machinery* and *use a relative path to prevent spamming*. This means that a batch request to Tyk for three resources with the same API key will have three requests applied to their session quota and request limiting could become active if they are being throttled. 141 142 Tyk reconstructs the API request based on the data in the batch request. This is to ensure that Tyk is not being used to proxy requests to other hosts outside of the upstream API being accessed. 143 144 Batch requests are created by POSTing to the `/{listen_path}/tyk/batch/` endpoint. These requests **do not require a valid key**, but their request list does. 145 146 <h3>Sample Request</h3> 147 148 ```{json} 149 { 150 "requests": [ 151 { 152 "method": "GET", 153 "headers": { 154 "x-tyk-test": "1", 155 "x-tyk-version": "1.2", 156 "authorization": "1dbc83b9c431649d7698faa9797e2900f" 157 }, 158 "body": "", 159 "relative_url": "get" 160 }, 161 { 162 "method": "GET", 163 "headers": { 164 "x-tyk-test": "2", 165 "x-tyk-version": "1.2", 166 "authorization": "1dbc83b9c431649d7698faa9797e2900f" 167 }, 168 "body": "", 169 "relative_url": "get" 170 } 171 ], 172 "suppress_parallel_execution": false 173 } 174 ``` 175 176 The response will will be a structured reply that encapsulates the responses for each of the outbound requests. If `suppress_parallel_execution` is set to `true`, requests will be made synchronously. If set to `false` then they will run in parallel and the response order is not guaranteed. 177 178 <h3>Sample Response</h3> 179 180 ``` 181 [ 182 { 183 "relative_url": "get", 184 "code": 200, 185 "headers": { 186 "Access-Control-Allow-Credentials": [ 187 "true" 188 ], 189 "Access-Control-Allow-Origin": [ 190 "*" 191 ], 192 "Content-Length": [ 193 "497" 194 ], 195 "Content-Type": [ 196 "application/json" 197 ], 198 "Date": [ 199 "Wed, 12 Nov 2014 15:32:43 GMT" 200 ], 201 "Server": [ 202 "gunicorn/18.0" 203 ], 204 "Via": [ 205 "1.1 vegur" 206 ] 207 }, 208 "body": "{ 209 "args": {}, 210 "headers": { 211 "Accept-Encoding": "gzip", 212 "Authorization": "1dbc83b9c431649d7698faa9797e2900f", 213 "Connect-Time": "2", 214 "Connection": "close", 215 "Host": "httpbin.org", 216 "Total-Route-Time": "0", 217 "User-Agent": "Go 1.1 package http", 218 "Via": "1.1 vegur", 219 "X-Request-Id": "6a22499a-2776-4aa1-80c0-686581a8be4d", 220 "X-Tyk-Test": "2", 221 "X-Tyk-Version": "1.2" 222 }, 223 "origin": "127.0.0.1, 62.232.114.250", 224 "url": "http://httpbin.org/get" 225 }" 226 }, 227 { 228 "relative_url": "get", 229 "code": 200, 230 "headers": { 231 "Access-Control-Allow-Credentials": [ 232 "true" 233 ], 234 "Access-Control-Allow-Origin": [ 235 "*" 236 ], 237 "Content-Length": [ 238 "497" 239 ], 240 "Content-Type": [ 241 "application/json" 242 ], 243 "Date": [ 244 "Wed, 12 Nov 2014 15:32:43 GMT" 245 ], 246 "Server": [ 247 "gunicorn/18.0" 248 ], 249 "Via": [ 250 "1.1 vegur" 251 ] 252 }, 253 "body": "{ 254 "args": {}, 255 "headers": { 256 "Accept-Encoding": "gzip", 257 "Authorization": "1dbc83b9c431649d7698faa9797e2900f", 258 "Connect-Time": "7", 259 "Connection": "close", 260 "Host": "httpbin.org", 261 "Total-Route-Time": "0", 262 "User-Agent": "Go 1.1 package http", 263 "Via": "1.1 vegur", 264 "X-Request-Id": "1ab61f50-51ff-4828-a7e2-17240385a6d2", 265 "X-Tyk-Test": "1", 266 "X-Tyk-Version": "1.2" 267 }, 268 "origin": "127.0.0.1, 62.232.114.250", 269 "url": "http://httpbin.org/get" 270 }" 271 } 272 ] 273 ``` 274 With the body for each request string encoded in the `body` field. 275 276 * `expire_analytics_after`: If you are running a busy API, you may want to ensure that your MongoDB database does not overflow with old data. Set the `expire_analytics_after` value to the number of seconds you would like the data to last for. Setting this flag to anything above `0` will set an `expireAt` field for each record that is written to the database. 277 278 **Important:** Tyk will not create the expiry index for you. In order to implement data expiry for your analytics data, ensure that the index is created This is easily achieved using the [MongoDB command line interface](https://docs.mongodb.com/getting-started/shell/client/). 279 280 * `dont_set_quota_on_create`: This setting defaults to `false`, but if set to `true`, when the API is used to edit, create or add keys, the quota cache in Redis will not be re-set. By default, all updates or creates to Keys that have Quotas set will re-set the quota (This has been the default behaviour since 1.0). 281 282 This behaviour can be bypassed on a case-by-case basis by using the `suppress_reset` parameter when making a REST API request. This is the advised mode of operation as it allows for manual, granular control over key quotas and reset timings. 283 284 * `cache_options`: This section enables you to configure the caching behaviour of Tyk and to enable or disable the caching middleware for your API. 285 286 * `cache_options.enable_cache`: Set this value to `true` if the cache should be enabled for this endpoint, setting it to false will stop all caching behaviour. 287 288 * `cache_options.cache_timeout`: The amount of time, in seconds, to keep cached objects, defaults to `60` seconds. 289 290 * `cache_options.cache_all_safe_requests`: Set this to `true` if you want all *safe* requests (GET, HEAD, OPTIONS) to be cached. This is a blanket setting for APIs where caching is required but you don't want to set individual paths up in the definition. 291 292 * `cache_options.enable_upstream_cache_control`: Set this to `true` if you want your application to control the cache options for Tyk (TTL and whether to cache or not). See [Caching](/docs/reduce-latency/caching/) for more details. 293 294 * `response_processors`: Response processors need to be specifically defined so they are loaded on API creation, otherwise the middleware will not fire. In order to have the two main response middleware components fire, the following configuration object should be supplied. 295 296 ```{json} 297 "response_processors": [ 298 { 299 "name": "header_injector", 300 "options": { 301 "add_headers": {"name": "value"}, 302 "remove_headers": ["name"] 303 } 304 }, 305 { 306 "name": "response_body_transform", 307 "options": {} 308 } 309 ] 310 ``` 311 The options for the `header_injector` are global, and will apply to all outbound requests. 312 313 314 - name: APIs 315 description: |- 316 **Note: Applies only to Tyk Gateway Community Edition** 317 318 API Management is very simple using the Tyk REST API: each update only affects the underlying file, and this endpoint will only work with disk based installations, not Database-backed ones. 319 320 APIs that are added this way are flushed to to disk into the app_path folder using the format: `{api-id}.json`. Updating existing APIs that use a different naming convention will cause those APIs to be added, which could subsequently lead to a loading error and crash if they use the same listen_path. 321 322 These methods only work on a single API node. If updating a cluster, it is important to ensure that all nodes are updated before initiating a reload. 323 paths: 324 /tyk/apis: 325 get: 326 description: |- 327 List APIs 328 Only if used without the Tyk Dashboard 329 tags: 330 - APIs 331 operationId: listApis 332 responses: 333 '200': 334 description: List of API definitions 335 content: 336 application/json: 337 schema: 338 type: array 339 items: 340 $ref: '#/components/schemas/APIDefinition' 341 example: 342 - name: "TestAPI" 343 use_keyless: true 344 active: true 345 proxy: 346 listen_path: "/test" 347 post: 348 description: |- 349 Create API 350 A single Tyk node can have its API Definitions queried, deleted and updated remotely. This functionality enables you to remotely update your Tyk definitions without having to manage the files manually. 351 tags: 352 - APIs 353 operationId: createApi 354 requestBody: 355 content: 356 application/json: 357 schema: 358 $ref: "#/components/schemas/APIDefinition" 359 example: 360 name: "TestAPI" 361 use_keyless: true 362 active: true 363 proxy: 364 listen_path: "/test" 365 responses: 366 '200': 367 description: API created 368 content: 369 application/json: 370 schema: 371 $ref: "#/components/schemas/apiModifyKeySuccess" 372 example: 373 status: "ok" 374 action: "created" 375 key: "{...API JSON definition...}" 376 '400': 377 description: Malformed data 378 content: 379 application/json: 380 schema: 381 $ref: "#/components/schemas/apiStatusMessage" 382 example: 383 status: "error" 384 message: "Malformed API data" 385 '/tyk/apis/{apiID}': 386 parameters: 387 - description: The API ID 388 name: apiID 389 in: path 390 required: true 391 schema: 392 type: string 393 get: 394 description: |- 395 Get API definition 396 Only if used without the Tyk Dashboard 397 tags: 398 - APIs 399 operationId: getApi 400 responses: 401 '200': 402 description: API definition 403 content: 404 application/json: 405 schema: 406 $ref: "#/components/schemas/APIDefinition" 407 example: 408 name: "TestAPI" 409 use_keyless: true 410 active: true 411 proxy: 412 listen_path: "/test" 413 put: 414 description: | 415 Updating an API definition uses the same signature an object as a `POST`, however it will first ensure that the API ID that is being updated is the same as the one in the object being `PUT`. 416 417 418 Updating will completely replace the file descriptor and will not change an API Definition that has already been loaded, the hot-reload endpoint will need to be called to push the new definition to live. 419 tags: 420 - APIs 421 operationId: updateApi 422 requestBody: 423 content: 424 application/json: 425 schema: 426 $ref: "#/components/schemas/APIDefinition" 427 example: 428 name: "TestAPI" 429 use_keyless: true 430 active: true 431 proxy: 432 listen_path: "/test" 433 responses: 434 '200': 435 description: API updated 436 content: 437 application/json: 438 schema: 439 $ref: "#/components/schemas/apiModifyKeySuccess" 440 example: 441 status: "ok" 442 action: "updated" 443 key: "{...API JSON definition...}" 444 '400': 445 description: Malformed data 446 content: 447 application/json: 448 schema: 449 $ref: "#/components/schemas/apiStatusMessage" 450 example: 451 status: "error" 452 message: "Malformed API data" 453 454 delete: 455 description: |- 456 Deleting an API definition will remove the file from the file store, the API definition will NOT be unloaded, a separate reload request will need to be made to disable the API endpoint. 457 tags: 458 - APIs 459 operationId: deleteApi 460 responses: 461 '200': 462 description: API deleted 463 content: 464 application/json: 465 schema: 466 $ref: '#/components/schemas/apiStatusMessage' 467 example: 468 message: API deleted 469 status: ok 470 '400': 471 description: No API ID specified 472 content: 473 application/json: 474 schema: 475 $ref: '#/components/schemas/apiStatusMessage' 476 example: 477 message: API ID not specified 478 status: error 479 '/tyk/cache/{apiID}': 480 parameters: 481 - description: The API ID 482 name: apiID 483 in: path 484 required: true 485 schema: 486 type: string 487 delete: 488 summary: Invalidate cache 489 description: Invalidate cache for given API 490 tags: 491 - Cache Invalidation 492 operationId: invalidateCache 493 responses: 494 '200': 495 description: Invalidate cache 496 content: 497 application/json: 498 schema: 499 $ref: '#/components/schemas/apiStatusMessage' 500 example: 501 message: cache invalidated 502 status: ok 503 '/tyk/reload/': 504 get: 505 summary: Hot-reload a single node 506 description: Tyk is capable of reloading configurations without having to stop serving requests, this means that API configurations can be added at runtime, or even modified at runtime and those rules applied immediately without any downtime. 507 parameters: 508 - description: Block a response, until the reload is performed. This can be useful in scripting environments like CI/CD workflows. 509 name: block 510 in: query 511 required: false 512 schema: 513 type: boolean 514 enum: [true] 515 tags: 516 - Hot Reload 517 operationId: hotReload 518 responses: 519 '200': 520 description: Reload gateway 521 content: 522 application/json: 523 schema: 524 $ref: '#/components/schemas/apiStatusMessage' 525 example: 526 status: ok 527 '/tyk/reload/group': 528 get: 529 summary: Hot-reload a Tyk group 530 description: To reload a whole group of Tyk nodes (without using the Dashboard or host manager), you can send an API request to a single node, this node will then send a notification through the pub/sub infrastructure to all other listening nodes (including the host manager if it is being used to manage NginX) which will then trigger a global reload. 531 tags: 532 - Hot Reload 533 operationId: hotReloadGroup 534 responses: 535 '200': 536 description: Reload gateway 537 content: 538 application/json: 539 schema: 540 $ref: '#/components/schemas/apiStatusMessage' 541 example: 542 status: ok 543 '/tyk/hello': 544 get: 545 summary: Check the Health of the Gateway 546 description: | 547 From v2.7.5 you can now rename the `/hello` endpoint by using the `health_check_endpoint_name` option 548 549 Returns 200 response in case of success 550 tags: 551 - Health Checking 552 operationId: hello 553 responses: 554 '200': 555 description: Success 556 content: 557 text/html: 558 schema: 559 type: string 560 example: "Hello Tiki" 561 '/tyk/{listenPath}/hello': 562 parameters: 563 - in: path 564 name: listenPath 565 required: true 566 description: "Listen path of loaded API" 567 schema: 568 type: string 569 get: 570 summary: Check the Health of the API 571 description: Should point to API domain if it has own 572 tags: 573 - Health Checking 574 operationId: helloAPI 575 responses: 576 '200': 577 description: Success 578 content: 579 text/html: 580 schema: 581 type: string 582 example: "Hello Tiki" 583 /tyk/keys: 584 get: 585 summary: List Keys 586 description: You can retrieve all the keys in your Tyk instance. Returns an array of Key IDs. 587 tags: 588 - Keys 589 operationId: listKeys 590 responses: 591 '200': 592 description: List of all API keys 593 content: 594 application/json: 595 schema: 596 type: array 597 items: 598 type: string 599 post: 600 summary: Create a key 601 description: |- 602 Tyk will generate the access token based on the OrgID specified in the API Definition and a random UUID. This ensures that keys can be "owned" by different API Owners should segmentation be needed at an organisational level. 603 <br/><br/> 604 API keys without access_rights data will be written to all APIs on the system (this also means that they will be created across all SessionHandlers and StorageHandlers, it is recommended to always embed access_rights data in a key to ensure that only targeted APIs and their back-ends are written to. 605 tags: 606 - Keys 607 operationId: addKey 608 requestBody: 609 content: 610 application/json: 611 schema: 612 $ref: "#/components/schemas/SessionState" 613 example: 614 quota_max: 60 615 quota_renews: 1406121006 616 quota_renewal_rate: 60 617 allowance: 100 618 rate: 100 619 per: 5 620 org_id: 53ac07777cbb8c2d53000002 621 responses: 622 '200': 623 description: New Key added 624 content: 625 application/json: 626 schema: 627 $ref: '#/components/schemas/apiModifyKeySuccess' 628 example: 629 action: created 630 key: '{...KEY JSON definition...}' 631 status: ok 632 '400': 633 description: Malformed data 634 content: 635 application/json: 636 schema: 637 $ref: '#/components/schemas/apiStatusMessage' 638 example: 639 message: Malformed Key data 640 status: error 641 '/tyk/keys/{keyID}': 642 parameters: 643 - description: The Key ID 644 name: keyID 645 in: path 646 required: true 647 schema: 648 type: string 649 get: 650 summary: Get a Key 651 description: Get session info about the specified key. Should return up to date rate limit and quota usage numbers. 652 tags: 653 - Keys 654 operationId: getKey 655 responses: 656 '200': 657 description: Key object 658 content: 659 application/json: 660 schema: 661 $ref: '#/components/schemas/SessionState' 662 example: 663 quota_max: 60 664 quota_renews: 1406121006 665 quota_renewal_rate: 60 666 allowance: 100 667 rate: 100 668 per: 5 669 org_id: 53ac07777cbb8c2d53000002 670 put: 671 summary: Update Key or Add custom Key 672 description: |- 673 You can also manually add keys to Tyk using your own key-generation algorithm. It is recommended if using this approach to ensure that the OrgID being used in the API Definition and the key data is blank so that Tyk does not try to prepend or manage the key in any way. 674 tags: 675 - Keys 676 operationId: updateKey 677 requestBody: 678 content: 679 application/json: 680 schema: 681 $ref: "#/components/schemas/SessionState" 682 example: 683 quota_max: 60 684 quota_renews: 1406121006 685 quota_renewal_rate: 60 686 allowance: 100 687 rate: 100 688 per: 5 689 org_id: 53ac07777cbb8c2d53000002 690 parameters: 691 - description: |- 692 Adding the suppress_reset parameter and setting it to 1, will cause Tyk not to reset the quota limit that is in the current live quota manager. By default Tyk will reset the quota in the live quota manager (initialising it) when adding a key. Adding the `suppress_reset` flag to the URL parameters will avoid this behaviour. 693 name: suppress_reset 694 in: query 695 required: false 696 schema: 697 type: string 698 enum: ["1"] 699 responses: 700 '200': 701 description: Key updated 702 content: 703 application/json: 704 schema: 705 $ref: '#/components/schemas/apiModifyKeySuccess' 706 example: 707 action: updated 708 status: ok 709 '400': 710 description: No or incorrect Key ID specified 711 content: 712 application/json: 713 schema: 714 $ref: '#/components/schemas/apiStatusMessage' 715 example: 716 message: Key ID not specified 717 status: error 718 delete: 719 summary: Delete Key 720 description: Deleting a key will remove it permanently from the system, however analytics relating to that key will still be available. 721 tags: 722 - Keys 723 operationId: deleteKey 724 responses: 725 '200': 726 description: Key deleted 727 content: 728 application/json: 729 schema: 730 $ref: '#/components/schemas/apiStatusMessage' 731 example: 732 action: Key deleted 733 status: ok 734 /tyk/oauth/clients/create: 735 post: 736 summary: Create new OAuth client 737 description: Any OAuth keys must be generated with the help of a client ID. These need to be pre-registered with Tyk before they can be used (in a similar vein to how you would register your app with Twitter before attempting to ask user permissions using their API). 738 <br/><br/> 739 <h3>Creating OAuth clients with Access to Multiple APIs</h3> 740 New from Tyk Gateway 2.6.0 is the ability to create OAuth clients with access to more than one API. If you provide the api_id it works the same as in previous releases. If you don¿ït provide the api_id the request uses policy access rights and enumerates APIs from their setting in the newly created OAuth-client. 741 742 743 tags: 744 - OAuth 745 operationId: createOAuthClient 746 requestBody: 747 content: 748 application/json: 749 schema: 750 $ref: "#/components/schemas/NewClientRequest" 751 example: 752 client_id: test 753 api_id: id 754 policy_id: policy 755 responses: 756 '200': 757 description: Client created 758 content: 759 application/json: 760 schema: 761 $ref: '#/components/schemas/NewClientRequest' 762 example: 763 client_id: test 764 api_id: id 765 policy_id: policy 766 '/tyk/oauth/clients/{apiID}': 767 get: 768 summary: List oAuth clients 769 description: OAuth Clients are organised by API ID, and therefore are queried as such. 770 tags: 771 - OAuth 772 operationId: listOAuthClients 773 parameters: 774 - description: The API ID 775 name: apiID 776 in: path 777 required: true 778 schema: 779 type: string 780 responses: 781 '200': 782 description: Get OAuth client details or a list of OAuth clients 783 content: 784 application/json: 785 schema: 786 type: array 787 items: 788 $ref: '#/components/schemas/NewClientRequest' 789 '/tyk/oauth/clients/{apiID}/{keyName}': 790 get: 791 summary: Get OAuth client 792 tags: 793 - OAuth 794 operationId: getOAuthClient 795 parameters: 796 - description: The API ID 797 name: apiID 798 in: path 799 required: true 800 schema: 801 type: string 802 minimum: 1 803 - description: The Client ID 804 name: keyName 805 in: path 806 required: true 807 schema: 808 type: string 809 responses: 810 '200': 811 description: Get OAuth client details or a list of OAuth clients 812 content: 813 application/json: 814 schema: 815 $ref: '#/components/schemas/NewClientRequest' 816 example: 817 client_id: test 818 api_id: id 819 policy_id: policy 820 delete: 821 summary: Delete OAuth client 822 description: Please note that tokens issued with the client ID will still be valid until they expire. 823 tags: 824 - OAuth 825 operationId: deleteOAuthClient 826 parameters: 827 - description: The API ID 828 name: apiID 829 in: path 830 required: true 831 schema: 832 type: string 833 minimum: 1 834 - description: The Client ID 835 name: keyName 836 in: path 837 required: true 838 schema: 839 type: string 840 responses: 841 '200': 842 description: OAuth client deleted 843 content: 844 application/json: 845 schema: 846 $ref: '#/components/schemas/apiModifyKeySuccess' 847 example: 848 action: deleted 849 status: ok 850 '/tyk/oauth/clients/{apiID}/{keyName}/tokens': 851 get: 852 summary: List tokens 853 description: This endpoint allows you to retrieve a list of all current tokens and their expiry date for a provided API ID and OAuth-client ID in the following format. This endpoint will work only for newly created tokens. 854 <br/> 855 <br/> 856 You can control how long you want to store expired tokens in this list using `oauth_token_expired_retain_period` gateway option, which specifies retain period for expired tokens stored in Redis. By default expired token not get removed. See <a href="https://tyk.io/docs/configure/tyk-gateway-configuration-options/#a-name-oauth-token-expired-retain-period-a-oauth-token-expired-retain-period" target="_blank">here</a> for more details. 857 tags: 858 - OAuth 859 operationId: getOAuthClientTokens 860 parameters: 861 - description: The API ID 862 name: apiID 863 in: path 864 required: true 865 schema: 866 type: string 867 minimum: 1 868 - description: The Client ID 869 name: keyName 870 in: path 871 required: true 872 schema: 873 type: string 874 responses: 875 '200': 876 description: Get a list of tokens 877 content: 878 application/json: 879 schema: 880 type: array 881 items: 882 type: string 883 example: 884 - "tok1" 885 - "tok2" 886 '/tyk/oauth/refresh/{keyName}': 887 delete: 888 summary: Invalidate OAuth refresh token 889 description: It is possible to invalidate refresh tokens in order to manage OAuth client access more robustly. 890 tags: 891 - OAuth 892 operationId: invalidateOAuthRefresh 893 parameters: 894 - description: The API id 895 name: api_id 896 in: query 897 required: true 898 schema: 899 type: string 900 - description: Refresh token 901 name: keyName 902 in: path 903 required: true 904 schema: 905 type: string 906 responses: 907 '200': 908 description: Deleted 909 content: 910 application/json: 911 schema: 912 $ref: '#/components/schemas/apiModifyKeySuccess' 913 '/tyk/oauth/authorize-client/': 914 post: 915 description: With the OAuth flow you will need to create authorisation or access tokens for your clients, in order to do this, Tyk provides a private API endpoint for your application to generate these codes and redirect the end-user back to the API Client. 916 summary: Authorize client 917 requestBody: 918 required: true 919 content: 920 application/x-www-form-urlencoded: 921 schema: 922 type: object 923 properties: 924 response_type: 925 description: Should be provided by requesting client as part of authorisation request, this should be either `code` or `token` depending on the methods you have specified for the API. 926 type: string 927 client_id: 928 description: Should be provided by requesting client as part of authorisation request. The Client ID that is making the request. 929 type: string 930 redirect_uri: 931 description: Should be provided by requesting client as part of authorisation request. Must match with the record stored with Tyk. 932 type: string 933 key_rules: 934 description: A string representation of a Session Object (form-encoded). This should be provided by your application in order to apply any quotas or rules to the key. 935 type: string 936 example: 937 response_type: code 938 client_id: 21e2baf424674f6461faca6d45285bbb 939 redirect_uri: http%3A%2F%2Foauth.com%2Fredirect 940 key_rules: '%7B+++++%22allowance%22%3A+999%2C+++++%22rate%22%3A+1000%2C+++++%22per%22%3A+60%2C+++++%22expires%22%3A+0%2C+++++%22quota_max%22%3A+-1%2C+++++%22quota_renews%22%3A+1406121006%2C+++++%22quota_remaining%22%3A+0%2C+++++%22quota_renewal_rate%22%3A+60%2C+++++%22access_rights%22%3A+%7B+++++++++%22528a67c1ac9940964f9a41ae79235fcc%22%3A+%7B+++++++++++++%22api_name%22%3A+%22OAuth+Test+API%22%2C+++++++++++++%22api_id%22%3A+%22528a67c1ac9940964f9a41ae79235fcc%22%2C+++++++++++++%22versions%22%3A+%5B+++++++++++++++++%22Default%22+++++++++++++%5D+++++++++%7D+++++%7D%2C+++++%22org_id%22%3A+%2253ac07777cbb8c2d53000002%22+%7D' 941 tags: 942 - OAuth 943 operationId: authorizeClient 944 responses: 945 '200': 946 description: Succesful response 947 content: 948 application/json: 949 schema: 950 type: object 951 example: 952 code: MWY0ZDRkMzktOTYwNi00NDRiLTk2YmQtOWQxOGQ3Mjc5Yzdk 953 redirect_to: 'http://client-app.com/oauth-redirect/?code=MWY0ZDRkMzktOTYwNi00NDRiLTk2YmQtOWQxOGQ3Mjc5Yzdk' 954 /tyk/org/keys: 955 get: 956 summary: List Organisation Keys 957 description: |- 958 You can now set rate limits at the organisation level by using the following fields - allowance and rate. These are the number of allowed requests for the specified per value, and need to be set to the same value. If you don¿ït want to have organisation level rate limiting, set ¿írate¿ì or ¿íper¿ì to zero, or don¿ït add them to your request. 959 tags: 960 - Organisation Quotas 961 operationId: listOrgKeys 962 responses: 963 '200': 964 description: List of all API keys 965 content: 966 application/json: 967 schema: 968 type: object 969 properties: 970 keys: 971 type: array 972 items: 973 type: string 974 example: 975 keys: 976 - "key1" 977 - "key2" 978 post: 979 summary: Create an organisation key 980 description: |- 981 This work similar to Keys API except that Key ID is always equals Organisation ID 982 tags: 983 - Organisation Quotas 984 operationId: addOrgKey 985 requestBody: 986 content: 987 application/json: 988 schema: 989 $ref: "#/components/schemas/SessionState" 990 example: 991 quota_max: 60 992 quota_renews: 1406121006 993 quota_renewal_rate: 60 994 allowance: 100 995 rate: 100 996 per: 5 997 org_id: 53ac07777cbb8c2d53000002 998 responses: 999 '200': 1000 description: New Key added 1001 content: 1002 application/json: 1003 schema: 1004 $ref: '#/components/schemas/apiModifyKeySuccess' 1005 example: 1006 action: created 1007 key: '{...KEY JSON definition...}' 1008 status: ok 1009 '/tyk/orgs/keys/{keyID}': 1010 parameters: 1011 - description: The Key ID 1012 name: keyID 1013 in: path 1014 required: true 1015 schema: 1016 type: string 1017 get: 1018 summary: Get an Organisation Key 1019 description: Get session info about specified orgnanisation key. Should return up to date rate limit and quota usage numbers. 1020 tags: 1021 - Organisation Quotas 1022 operationId: getOrgKey 1023 responses: 1024 '200': 1025 description: Key object 1026 content: 1027 application/json: 1028 schema: 1029 $ref: '#/components/schemas/SessionState' 1030 put: 1031 summary: Update Organisation Key 1032 description: |- 1033 This work similar to Keys API except that Key ID is always equals Organisation ID 1034 1035 For Gateway v2.6.0 onwards, you can now set rate limits at the organisation level by using the following fields - allowance and rate. These are the number of allowed requests for the specified per value, and need to be set to the same value. If you don¿ït want to have organisation level rate limiting, set `rate` or `per` to zero, or don¿ït add them to your request. 1036 tags: 1037 - Organisation Quotas 1038 operationId: updateOrgKey 1039 requestBody: 1040 content: 1041 application/json: 1042 schema: 1043 $ref: "#/components/schemas/SessionState" 1044 example: 1045 quota_max: 60 1046 quota_renews: 1406121006 1047 quota_renewal_rate: 60 1048 allowance: 100 1049 rate: 100 1050 per: 5 1051 org_id: 53ac07777cbb8c2d53000002 1052 parameters: 1053 - description: |- 1054 Adding the `reset_quota` parameter and setting it to 1, will cause Tyk reset the organisations quota in the live quota manager, it is recommended to use this mechanism to reset organisation-level access if a monthly subscription is in place. 1055 name: reset_quota 1056 in: query 1057 required: false 1058 schema: 1059 type: string 1060 enum: ["1"] 1061 responses: 1062 '200': 1063 description: Key updated 1064 content: 1065 application/json: 1066 schema: 1067 $ref: '#/components/schemas/apiModifyKeySuccess' 1068 example: 1069 action: updated 1070 status: ok 1071 delete: 1072 summary: Delete Organisation Key 1073 description: Deleting a key will remove all limits from organisation. It does not affects regualar keys created within organisation. 1074 tags: 1075 - Organisation Quotas 1076 operationId: deleteOrgKey 1077 responses: 1078 '200': 1079 description: Key deleted 1080 content: 1081 application/json: 1082 schema: 1083 $ref: '#/components/schemas/apiStatusMessage' 1084 example: 1085 action: Key deleted 1086 status: ok 1087 /{listen_path}/tyk/batch: 1088 parameters: 1089 - name: listen_path 1090 in: path 1091 required: true 1092 description: "API listen path" 1093 schema: 1094 type: string 1095 post: 1096 summary: Run batch request 1097 tags: 1098 - Batch requests 1099 operationId: batch 1100 responses: 1101 '200': 1102 $ref: '#/components/schemas/apiStatusMessage' 1103 components: 1104 responses: 1105 parameterBodies: 1106 content: 1107 application/json: 1108 schema: 1109 $ref: '#/components/schemas/OAuthClientToken' 1110 description: parameterBodies 1111 schemas: 1112 APIDefinition: 1113 properties: 1114 tags: 1115 items: 1116 type: string 1117 type: array 1118 x-go-name: Tags 1119 CORS: 1120 properties: 1121 allow_credentials: 1122 type: boolean 1123 x-go-name: AllowCredentials 1124 allowed_headers: 1125 items: 1126 type: string 1127 type: array 1128 x-go-name: AllowedHeaders 1129 allowed_methods: 1130 items: 1131 type: string 1132 type: array 1133 x-go-name: AllowedMethods 1134 allowed_origins: 1135 items: 1136 type: string 1137 type: array 1138 x-go-name: AllowedOrigins 1139 debug: 1140 type: boolean 1141 x-go-name: Debug 1142 enable: 1143 type: boolean 1144 x-go-name: Enable 1145 exposed_headers: 1146 items: 1147 type: string 1148 type: array 1149 x-go-name: ExposedHeaders 1150 max_age: 1151 format: int64 1152 type: integer 1153 x-go-name: MaxAge 1154 options_passthrough: 1155 type: boolean 1156 x-go-name: OptionsPassthrough 1157 type: object 1158 active: 1159 type: boolean 1160 x-go-name: Active 1161 allowed_ips: 1162 items: 1163 type: string 1164 type: array 1165 x-go-name: AllowedIPs 1166 api_id: 1167 type: string 1168 x-go-name: APIID 1169 auth: 1170 $ref: '#/components/schemas/Auth' 1171 auth_provider: 1172 $ref: '#/components/schemas/AuthProviderMeta' 1173 base_identity_provided_by: 1174 $ref: '#/components/schemas/AuthTypeEnum' 1175 basic_auth: 1176 properties: 1177 body_password_regexp: 1178 type: string 1179 x-go-name: BodyPasswordRegexp 1180 body_user_regexp: 1181 type: string 1182 x-go-name: BodyUserRegexp 1183 cache_ttl: 1184 format: int64 1185 type: integer 1186 x-go-name: CacheTTL 1187 disable_caching: 1188 type: boolean 1189 x-go-name: DisableCaching 1190 extract_from_body: 1191 type: boolean 1192 x-go-name: ExtractFromBody 1193 type: object 1194 x-go-name: BasicAuth 1195 blacklisted_ips: 1196 items: 1197 type: string 1198 type: array 1199 x-go-name: BlacklistedIPs 1200 cache_options: 1201 $ref: '#/components/schemas/CacheOptions' 1202 certificates: 1203 items: 1204 type: string 1205 type: array 1206 x-go-name: Certificates 1207 client_certificates: 1208 items: 1209 type: string 1210 type: array 1211 x-go-name: ClientCertificates 1212 config_data: 1213 additionalProperties: 1214 type: object 1215 type: object 1216 x-go-name: ConfigData 1217 custom_middleware: 1218 $ref: '#/components/schemas/MiddlewareSection' 1219 custom_middleware_bundle: 1220 type: string 1221 x-go-name: CustomMiddlewareBundle 1222 definition: 1223 properties: 1224 key: 1225 type: string 1226 x-go-name: Key 1227 location: 1228 type: string 1229 x-go-name: Location 1230 strip_path: 1231 type: boolean 1232 x-go-name: StripPath 1233 type: object 1234 x-go-name: VersionDefinition 1235 disable_quota: 1236 type: boolean 1237 x-go-name: DisableQuota 1238 disable_rate_limit: 1239 type: boolean 1240 x-go-name: DisableRateLimit 1241 do_not_track: 1242 type: boolean 1243 x-go-name: DoNotTrack 1244 domain: 1245 type: string 1246 x-go-name: Domain 1247 dont_set_quota_on_create: 1248 type: boolean 1249 x-go-name: DontSetQuotasOnCreate 1250 enable_batch_request_support: 1251 type: boolean 1252 x-go-name: EnableBatchRequestSupport 1253 enable_context_vars: 1254 type: boolean 1255 x-go-name: EnableContextVars 1256 enable_coprocess_auth: 1257 type: boolean 1258 x-go-name: EnableCoProcessAuth 1259 enable_ip_blacklisting: 1260 type: boolean 1261 x-go-name: EnableIpBlacklisting 1262 enable_ip_whitelisting: 1263 type: boolean 1264 x-go-name: EnableIpWhiteListing 1265 enable_jwt: 1266 type: boolean 1267 x-go-name: EnableJWT 1268 enable_signature_checking: 1269 type: boolean 1270 x-go-name: EnableSignatureChecking 1271 event_handlers: 1272 $ref: '#/components/schemas/EventHandlerMetaConfig' 1273 expire_analytics_after: 1274 format: int64 1275 type: integer 1276 x-go-name: ExpireAnalyticsAfter 1277 global_rate_limit: 1278 $ref: '#/components/schemas/GlobalRateLimit' 1279 hmac_allowed_algorithms: 1280 items: 1281 type: string 1282 type: array 1283 x-go-name: HmacAllowedAlgorithms 1284 hmac_allowed_clock_skew: 1285 format: double 1286 type: number 1287 x-go-name: HmacAllowedClockSkew 1288 id: 1289 $ref: '#/components/schemas/ObjectId' 1290 internal: 1291 type: boolean 1292 x-go-name: Internal 1293 jwt_client_base_field: 1294 type: string 1295 x-go-name: JWTClientIDBaseField 1296 jwt_expires_at_validation_skew: 1297 format: uint64 1298 type: integer 1299 x-go-name: JWTExpiresAtValidationSkew 1300 jwt_identity_base_field: 1301 type: string 1302 x-go-name: JWTIdentityBaseField 1303 jwt_issued_at_validation_skew: 1304 format: uint64 1305 type: integer 1306 x-go-name: JWTIssuedAtValidationSkew 1307 jwt_not_before_validation_skew: 1308 format: uint64 1309 type: integer 1310 x-go-name: JWTNotBeforeValidationSkew 1311 jwt_policy_field_name: 1312 type: string 1313 x-go-name: JWTPolicyFieldName 1314 jwt_scope_claim_name: 1315 type: string 1316 x-go-name: JWTScopeClaimName 1317 jwt_scope_to_policy_mapping: 1318 additionalProperties: 1319 type: string 1320 type: object 1321 x-go-name: JWTScopeToPolicyMapping 1322 jwt_signing_method: 1323 type: string 1324 x-go-name: JWTSigningMethod 1325 jwt_skip_kid: 1326 type: boolean 1327 x-go-name: JWTSkipKid 1328 jwt_source: 1329 type: string 1330 x-go-name: JWTSource 1331 name: 1332 type: string 1333 x-go-name: Name 1334 notifications: 1335 $ref: '#/components/schemas/NotificationsManager' 1336 oauth_meta: 1337 properties: 1338 allowed_access_types: 1339 items: 1340 $ref: '#/components/schemas/AccessRequestType' 1341 type: array 1342 x-go-name: AllowedAccessTypes 1343 allowed_authorize_types: 1344 items: 1345 $ref: '#/components/schemas/AuthorizeRequestType' 1346 type: array 1347 x-go-name: AllowedAuthorizeTypes 1348 auth_login_redirect: 1349 type: string 1350 x-go-name: AuthorizeLoginRedirect 1351 type: object 1352 x-go-name: Oauth2Meta 1353 openid_options: 1354 $ref: '#/components/schemas/OpenIDOptions' 1355 org_id: 1356 type: string 1357 x-go-name: OrgID 1358 pinned_public_keys: 1359 additionalProperties: 1360 type: string 1361 type: object 1362 x-go-name: PinnedPublicKeys 1363 proxy: 1364 properties: 1365 check_host_against_uptime_tests: 1366 type: boolean 1367 x-go-name: CheckHostAgainstUptimeTests 1368 disable_strip_slash: 1369 type: boolean 1370 x-go-name: DisableStripSlash 1371 enable_load_balancing: 1372 type: boolean 1373 x-go-name: EnableLoadBalancing 1374 listen_path: 1375 type: string 1376 x-go-name: ListenPath 1377 preserve_host_header: 1378 type: boolean 1379 x-go-name: PreserveHostHeader 1380 service_discovery: 1381 $ref: '#/components/schemas/ServiceDiscoveryConfiguration' 1382 strip_listen_path: 1383 type: boolean 1384 x-go-name: StripListenPath 1385 target_list: 1386 items: 1387 type: string 1388 type: array 1389 x-go-name: Targets 1390 target_url: 1391 type: string 1392 x-go-name: TargetURL 1393 transport: 1394 properties: 1395 proxy_url: 1396 type: string 1397 x-go-name: ProxyURL 1398 ssl_ciphers: 1399 items: 1400 type: string 1401 type: array 1402 x-go-name: SSLCipherSuites 1403 ssl_insecure_skip_verify: 1404 type: boolean 1405 x-go-name: SSLInsecureSkipVerify 1406 ssl_min_version: 1407 format: uint16 1408 type: integer 1409 x-go-name: SSLMinVersion 1410 type: object 1411 x-go-name: Transport 1412 type: object 1413 x-go-name: Proxy 1414 response_processors: 1415 items: 1416 $ref: '#/components/schemas/ResponseProcessor' 1417 type: array 1418 x-go-name: ResponseProcessors 1419 session_lifetime: 1420 format: int64 1421 type: integer 1422 x-go-name: SessionLifetime 1423 session_provider: 1424 $ref: '#/components/schemas/SessionProviderMeta' 1425 slug: 1426 type: string 1427 x-go-name: Slug 1428 strip_auth_data: 1429 type: boolean 1430 x-go-name: StripAuthData 1431 tag_headers: 1432 items: 1433 type: string 1434 type: array 1435 x-go-name: TagHeaders 1436 upstream_certificates: 1437 additionalProperties: 1438 type: string 1439 type: object 1440 x-go-name: UpstreamCertificates 1441 uptime_tests: 1442 properties: 1443 check_list: 1444 items: 1445 $ref: '#/components/schemas/HostCheckObject' 1446 type: array 1447 x-go-name: CheckList 1448 config: 1449 properties: 1450 expire_utime_after: 1451 format: int64 1452 type: integer 1453 x-go-name: ExpireUptimeAnalyticsAfter 1454 recheck_wait: 1455 format: int64 1456 type: integer 1457 x-go-name: RecheckWait 1458 service_discovery: 1459 $ref: '#/components/schemas/ServiceDiscoveryConfiguration' 1460 type: object 1461 x-go-name: Config 1462 type: object 1463 x-go-name: UptimeTests 1464 use_basic_auth: 1465 type: boolean 1466 x-go-name: UseBasicAuth 1467 use_keyless: 1468 type: boolean 1469 x-go-name: UseKeylessAccess 1470 use_mutual_tls_auth: 1471 type: boolean 1472 x-go-name: UseMutualTLSAuth 1473 use_oauth2: 1474 type: boolean 1475 x-go-name: UseOauth2 1476 use_openid: 1477 type: boolean 1478 x-go-name: UseOpenID 1479 use_standard_auth: 1480 type: boolean 1481 x-go-name: UseStandardAuth 1482 version_data: 1483 properties: 1484 default_version: 1485 type: string 1486 x-go-name: DefaultVersion 1487 not_versioned: 1488 type: boolean 1489 x-go-name: NotVersioned 1490 versions: 1491 additionalProperties: 1492 $ref: '#/components/schemas/VersionInfo' 1493 type: object 1494 x-go-name: Versions 1495 type: object 1496 x-go-name: VersionData 1497 title: >- 1498 APIDefinition represents the configuration for a single proxied API and 1499 it's versions. 1500 type: object 1501 x-go-package: github.com/TykTechnologies/tyk/apidef 1502 APILimit: 1503 description: APILimit stores quota and rate limit on ACL level (per API) 1504 properties: 1505 per: 1506 format: double 1507 type: number 1508 x-go-name: Per 1509 quota_max: 1510 format: int64 1511 type: integer 1512 x-go-name: QuotaMax 1513 quota_remaining: 1514 format: int64 1515 type: integer 1516 x-go-name: QuotaRemaining 1517 quota_renewal_rate: 1518 format: int64 1519 type: integer 1520 x-go-name: QuotaRenewalRate 1521 quota_renews: 1522 format: int64 1523 type: integer 1524 x-go-name: QuotaRenews 1525 rate: 1526 format: double 1527 type: number 1528 x-go-name: Rate 1529 set_by_policy: 1530 type: boolean 1531 x-go-name: SetByPolicy 1532 throttle_interval: 1533 format: double 1534 type: number 1535 x-go-name: ThrottleInterval 1536 throttle_retry_limit: 1537 format: int64 1538 type: integer 1539 x-go-name: ThrottleRetryLimit 1540 type: object 1541 x-go-package: github.com/TykTechnologies/tyk/user 1542 AccessDefinition: 1543 description: AccessDefinition defines which versions of an API a key has access to 1544 properties: 1545 allowed_urls: 1546 items: 1547 $ref: '#/components/schemas/AccessSpec' 1548 type: array 1549 x-go-name: AllowedURLs 1550 api_id: 1551 type: string 1552 x-go-name: APIID 1553 api_name: 1554 type: string 1555 x-go-name: APIName 1556 limit: 1557 $ref: '#/components/schemas/APILimit' 1558 versions: 1559 items: 1560 type: string 1561 type: array 1562 x-go-name: Versions 1563 type: object 1564 x-go-package: github.com/TykTechnologies/tyk/user 1565 AccessRequestType: 1566 description: AccessRequestType is the type for OAuth param `grant_type` 1567 type: string 1568 x-go-package: github.com/TykTechnologies/tyk/vendor/github.com/lonelycode/osin 1569 AccessSpec: 1570 description: >- 1571 AccessSpecs define what URLS a user has access to an what methods are 1572 enabled 1573 properties: 1574 methods: 1575 items: 1576 type: string 1577 type: array 1578 x-go-name: Methods 1579 url: 1580 type: string 1581 x-go-name: URL 1582 type: object 1583 x-go-package: github.com/TykTechnologies/tyk/user 1584 Auth: 1585 properties: 1586 auth_header_name: 1587 type: string 1588 x-go-name: AuthHeaderName 1589 cookie_name: 1590 type: string 1591 x-go-name: CookieName 1592 param_name: 1593 type: string 1594 x-go-name: ParamName 1595 signature: 1596 $ref: '#/components/schemas/SignatureConfig' 1597 use_certificate: 1598 type: boolean 1599 x-go-name: UseCertificate 1600 use_cookie: 1601 type: boolean 1602 x-go-name: UseCookie 1603 use_param: 1604 type: boolean 1605 x-go-name: UseParam 1606 validate_signature: 1607 type: boolean 1608 x-go-name: ValidateSignature 1609 type: object 1610 x-go-package: github.com/TykTechnologies/tyk/apidef 1611 AuthProviderCode: 1612 type: string 1613 x-go-package: github.com/TykTechnologies/tyk/apidef 1614 AuthProviderMeta: 1615 properties: 1616 meta: 1617 additionalProperties: 1618 type: object 1619 type: object 1620 x-go-name: Meta 1621 name: 1622 $ref: '#/components/schemas/AuthProviderCode' 1623 storage_engine: 1624 $ref: '#/components/schemas/StorageEngineCode' 1625 type: object 1626 x-go-package: github.com/TykTechnologies/tyk/apidef 1627 AuthTypeEnum: 1628 type: string 1629 x-go-package: github.com/TykTechnologies/tyk/apidef 1630 AuthorizeRequestType: 1631 description: AuthorizeRequestType is the type for OAuth param `response_type` 1632 type: string 1633 x-go-package: github.com/TykTechnologies/tyk/vendor/github.com/lonelycode/osin 1634 CacheMeta: 1635 properties: 1636 cache_response_codes: 1637 items: 1638 format: int64 1639 type: integer 1640 type: array 1641 x-go-name: CacheOnlyResponseCodes 1642 cache_key_regex: 1643 type: string 1644 x-go-name: CacheKeyRegex 1645 method: 1646 type: string 1647 x-go-name: Method 1648 path: 1649 type: string 1650 x-go-name: Path 1651 type: object 1652 x-go-package: github.com/TykTechnologies/tyk/apidef 1653 CacheOptions: 1654 properties: 1655 cache_all_safe_requests: 1656 type: boolean 1657 x-go-name: CacheAllSafeRequests 1658 cache_control_ttl_header: 1659 type: string 1660 x-go-name: CacheControlTTLHeader 1661 cache_response_codes: 1662 items: 1663 format: int64 1664 type: integer 1665 type: array 1666 x-go-name: CacheOnlyResponseCodes 1667 cache_timeout: 1668 format: int64 1669 type: integer 1670 x-go-name: CacheTimeout 1671 enable_cache: 1672 type: boolean 1673 x-go-name: EnableCache 1674 enable_upstream_cache_control: 1675 type: boolean 1676 x-go-name: EnableUpstreamCacheControl 1677 type: object 1678 x-go-package: github.com/TykTechnologies/tyk/apidef 1679 CircuitBreakerMeta: 1680 properties: 1681 method: 1682 type: string 1683 x-go-name: Method 1684 path: 1685 type: string 1686 x-go-name: Path 1687 return_to_service_after: 1688 format: int64 1689 type: integer 1690 x-go-name: ReturnToServiceAfter 1691 samples: 1692 format: int64 1693 type: integer 1694 x-go-name: Samples 1695 threshold_percent: 1696 format: double 1697 type: number 1698 x-go-name: ThresholdPercent 1699 type: object 1700 x-go-package: github.com/TykTechnologies/tyk/apidef 1701 EndPointMeta: 1702 properties: 1703 method_actions: 1704 additionalProperties: 1705 $ref: '#/components/schemas/EndpointMethodMeta' 1706 type: object 1707 x-go-name: MethodActions 1708 path: 1709 type: string 1710 x-go-name: Path 1711 type: object 1712 x-go-package: github.com/TykTechnologies/tyk/apidef 1713 EndpointMethodAction: 1714 type: string 1715 x-go-package: github.com/TykTechnologies/tyk/apidef 1716 EndpointMethodMeta: 1717 properties: 1718 action: 1719 $ref: '#/components/schemas/EndpointMethodAction' 1720 code: 1721 format: int64 1722 type: integer 1723 x-go-name: Code 1724 data: 1725 type: string 1726 x-go-name: Data 1727 headers: 1728 additionalProperties: 1729 type: string 1730 type: object 1731 x-go-name: Headers 1732 type: object 1733 x-go-package: github.com/TykTechnologies/tyk/apidef 1734 EventHandlerMetaConfig: 1735 properties: 1736 events: 1737 x-go-name: Events 1738 type: object 1739 x-go-package: github.com/TykTechnologies/tyk/apidef 1740 ExtendedPathsSet: 1741 properties: 1742 advance_cache_config: 1743 items: 1744 $ref: '#/components/schemas/CacheMeta' 1745 type: array 1746 x-go-name: AdvanceCacheConfig 1747 black_list: 1748 items: 1749 $ref: '#/components/schemas/EndPointMeta' 1750 type: array 1751 x-go-name: BlackList 1752 cache: 1753 items: 1754 type: string 1755 type: array 1756 x-go-name: Cached 1757 circuit_breakers: 1758 items: 1759 $ref: '#/components/schemas/CircuitBreakerMeta' 1760 type: array 1761 x-go-name: CircuitBreaker 1762 do_not_track_endpoints: 1763 items: 1764 $ref: '#/components/schemas/TrackEndpointMeta' 1765 type: array 1766 x-go-name: DoNotTrackEndpoints 1767 hard_timeouts: 1768 items: 1769 $ref: '#/components/schemas/HardTimeoutMeta' 1770 type: array 1771 x-go-name: HardTimeouts 1772 ignored: 1773 items: 1774 $ref: '#/components/schemas/EndPointMeta' 1775 type: array 1776 x-go-name: Ignored 1777 internal: 1778 items: 1779 $ref: '#/components/schemas/InternalMeta' 1780 type: array 1781 x-go-name: Internal 1782 method_transforms: 1783 items: 1784 $ref: '#/components/schemas/MethodTransformMeta' 1785 type: array 1786 x-go-name: MethodTransforms 1787 size_limits: 1788 items: 1789 $ref: '#/components/schemas/RequestSizeMeta' 1790 type: array 1791 x-go-name: SizeLimit 1792 track_endpoints: 1793 items: 1794 $ref: '#/components/schemas/TrackEndpointMeta' 1795 type: array 1796 x-go-name: TrackEndpoints 1797 transform: 1798 items: 1799 $ref: '#/components/schemas/TemplateMeta' 1800 type: array 1801 x-go-name: Transform 1802 transform_headers: 1803 items: 1804 $ref: '#/components/schemas/HeaderInjectionMeta' 1805 type: array 1806 x-go-name: TransformHeader 1807 transform_jq: 1808 items: 1809 $ref: '#/components/schemas/TransformJQMeta' 1810 type: array 1811 x-go-name: TransformJQ 1812 transform_jq_response: 1813 items: 1814 $ref: '#/components/schemas/TransformJQMeta' 1815 type: array 1816 x-go-name: TransformJQResponse 1817 transform_response: 1818 items: 1819 $ref: '#/components/schemas/TemplateMeta' 1820 type: array 1821 x-go-name: TransformResponse 1822 transform_response_headers: 1823 items: 1824 $ref: '#/components/schemas/HeaderInjectionMeta' 1825 type: array 1826 x-go-name: TransformResponseHeader 1827 url_rewrites: 1828 items: 1829 $ref: '#/components/schemas/URLRewriteMeta' 1830 type: array 1831 x-go-name: URLRewrite 1832 validate_json: 1833 items: 1834 $ref: '#/components/schemas/ValidatePathMeta' 1835 type: array 1836 x-go-name: ValidateJSON 1837 virtual: 1838 items: 1839 $ref: '#/components/schemas/VirtualMeta' 1840 type: array 1841 x-go-name: Virtual 1842 white_list: 1843 items: 1844 $ref: '#/components/schemas/EndPointMeta' 1845 type: array 1846 x-go-name: WhiteList 1847 type: object 1848 x-go-package: github.com/TykTechnologies/tyk/apidef 1849 GlobalRateLimit: 1850 properties: 1851 per: 1852 format: double 1853 type: number 1854 x-go-name: Per 1855 rate: 1856 format: double 1857 type: number 1858 x-go-name: Rate 1859 type: object 1860 x-go-package: github.com/TykTechnologies/tyk/apidef 1861 HardTimeoutMeta: 1862 properties: 1863 method: 1864 type: string 1865 x-go-name: Method 1866 path: 1867 type: string 1868 x-go-name: Path 1869 timeout: 1870 format: int64 1871 type: integer 1872 x-go-name: TimeOut 1873 type: object 1874 x-go-package: github.com/TykTechnologies/tyk/apidef 1875 HashType: 1876 type: string 1877 x-go-package: github.com/TykTechnologies/tyk/user 1878 HeaderInjectionMeta: 1879 properties: 1880 act_on: 1881 type: boolean 1882 x-go-name: ActOnResponse 1883 add_headers: 1884 additionalProperties: 1885 type: string 1886 type: object 1887 x-go-name: AddHeaders 1888 delete_headers: 1889 items: 1890 type: string 1891 type: array 1892 x-go-name: DeleteHeaders 1893 method: 1894 type: string 1895 x-go-name: Method 1896 path: 1897 type: string 1898 x-go-name: Path 1899 type: object 1900 x-go-package: github.com/TykTechnologies/tyk/apidef 1901 HostCheckObject: 1902 properties: 1903 body: 1904 type: string 1905 x-go-name: Body 1906 headers: 1907 additionalProperties: 1908 type: string 1909 type: object 1910 x-go-name: Headers 1911 method: 1912 type: string 1913 x-go-name: Method 1914 url: 1915 type: string 1916 x-go-name: CheckURL 1917 type: object 1918 x-go-package: github.com/TykTechnologies/tyk/apidef 1919 IdExtractorSource: 1920 type: string 1921 x-go-package: github.com/TykTechnologies/tyk/apidef 1922 IdExtractorType: 1923 type: string 1924 x-go-package: github.com/TykTechnologies/tyk/apidef 1925 InternalMeta: 1926 properties: 1927 method: 1928 type: string 1929 x-go-name: Method 1930 path: 1931 type: string 1932 x-go-name: Path 1933 type: object 1934 x-go-package: github.com/TykTechnologies/tyk/apidef 1935 MethodTransformMeta: 1936 properties: 1937 method: 1938 type: string 1939 x-go-name: Method 1940 path: 1941 type: string 1942 x-go-name: Path 1943 to_method: 1944 type: string 1945 x-go-name: ToMethod 1946 type: object 1947 x-go-package: github.com/TykTechnologies/tyk/apidef 1948 MiddlewareDefinition: 1949 properties: 1950 name: 1951 type: string 1952 x-go-name: Name 1953 path: 1954 type: string 1955 x-go-name: Path 1956 require_session: 1957 type: boolean 1958 x-go-name: RequireSession 1959 type: object 1960 x-go-package: github.com/TykTechnologies/tyk/apidef 1961 MiddlewareDriver: 1962 type: string 1963 x-go-package: github.com/TykTechnologies/tyk/apidef 1964 MiddlewareIdExtractor: 1965 properties: 1966 extract_from: 1967 $ref: '#/components/schemas/IdExtractorSource' 1968 extract_with: 1969 $ref: '#/components/schemas/IdExtractorType' 1970 extractor_config: 1971 additionalProperties: 1972 type: object 1973 type: object 1974 x-go-name: ExtractorConfig 1975 type: object 1976 x-go-package: github.com/TykTechnologies/tyk/apidef 1977 MiddlewareSection: 1978 properties: 1979 auth_check: 1980 $ref: '#/components/schemas/MiddlewareDefinition' 1981 driver: 1982 $ref: '#/components/schemas/MiddlewareDriver' 1983 id_extractor: 1984 $ref: '#/components/schemas/MiddlewareIdExtractor' 1985 post: 1986 items: 1987 $ref: '#/components/schemas/MiddlewareDefinition' 1988 type: array 1989 x-go-name: Post 1990 post_key_auth: 1991 items: 1992 $ref: '#/components/schemas/MiddlewareDefinition' 1993 type: array 1994 x-go-name: PostKeyAuth 1995 pre: 1996 items: 1997 $ref: '#/components/schemas/MiddlewareDefinition' 1998 type: array 1999 x-go-name: Pre 2000 response: 2001 items: 2002 $ref: '#/components/schemas/MiddlewareDefinition' 2003 type: array 2004 x-go-name: Response 2005 type: object 2006 x-go-package: github.com/TykTechnologies/tyk/apidef 2007 NewClientRequest: 2008 description: >- 2009 NewClientRequest is an outward facing JSON object translated from osin 2010 OAuthClients 2011 properties: 2012 api_id: 2013 type: string 2014 x-go-name: APIID 2015 client_id: 2016 type: string 2017 x-go-name: ClientID 2018 description: 2019 type: string 2020 x-go-name: Description 2021 meta_data: 2022 type: object 2023 x-go-name: MetaData 2024 policy_id: 2025 type: string 2026 x-go-name: PolicyID 2027 redirect_uri: 2028 type: string 2029 x-go-name: ClientRedirectURI 2030 secret: 2031 type: string 2032 x-go-name: ClientSecret 2033 type: object 2034 x-go-package: github.com/TykTechnologies/tyk 2035 NotificationsManager: 2036 description: 'TODO: Make this more generic' 2037 properties: 2038 oauth_on_keychange_url: 2039 type: string 2040 x-go-name: OAuthKeyChangeURL 2041 shared_secret: 2042 type: string 2043 x-go-name: SharedSecret 2044 title: >- 2045 NotificationsManager handles sending notifications to OAuth endpoints to 2046 notify the provider of key changes. 2047 type: object 2048 x-go-package: github.com/TykTechnologies/tyk/apidef 2049 OAuthClientToken: 2050 properties: 2051 code: 2052 type: string 2053 x-go-name: Token 2054 expires: 2055 format: int64 2056 type: integer 2057 x-go-name: Expires 2058 type: object 2059 x-go-package: github.com/TykTechnologies/tyk 2060 OIDProviderConfig: 2061 properties: 2062 client_ids: 2063 additionalProperties: 2064 type: string 2065 type: object 2066 x-go-name: ClientIDs 2067 issuer: 2068 type: string 2069 x-go-name: Issuer 2070 type: object 2071 x-go-package: github.com/TykTechnologies/tyk/apidef 2072 ObjectId: 2073 description: 'http://www.mongodb.org/display/DOCS/Object+IDs' 2074 title: >- 2075 ObjectId is a unique ID identifying a BSON value. It must be exactly 12 2076 bytes 2077 2078 long. MongoDB objects by default have such a property set in their "_id" 2079 2080 property. 2081 type: string 2082 x-go-package: github.com/TykTechnologies/tyk/vendor/gopkg.in/mgo.v2/bson 2083 OpenIDOptions: 2084 properties: 2085 providers: 2086 items: 2087 $ref: '#/components/schemas/OIDProviderConfig' 2088 type: array 2089 x-go-name: Providers 2090 segregate_by_client: 2091 type: boolean 2092 x-go-name: SegregateByClient 2093 type: object 2094 x-go-package: github.com/TykTechnologies/tyk/apidef 2095 Regexp: 2096 description: Regexp is a wrapper around regexp.Regexp but with caching 2097 properties: 2098 FromCache: 2099 type: boolean 2100 type: object 2101 x-go-package: github.com/TykTechnologies/tyk/regexp 2102 RequestInputType: 2103 type: string 2104 x-go-package: github.com/TykTechnologies/tyk/apidef 2105 RequestSizeMeta: 2106 properties: 2107 method: 2108 type: string 2109 x-go-name: Method 2110 path: 2111 type: string 2112 x-go-name: Path 2113 size_limit: 2114 format: int64 2115 type: integer 2116 x-go-name: SizeLimit 2117 type: object 2118 x-go-package: github.com/TykTechnologies/tyk/apidef 2119 ResponseProcessor: 2120 properties: 2121 name: 2122 type: string 2123 x-go-name: Name 2124 options: 2125 type: object 2126 x-go-name: Options 2127 type: object 2128 x-go-package: github.com/TykTechnologies/tyk/apidef 2129 RoutingTrigger: 2130 properties: 2131 'on': 2132 $ref: '#/components/schemas/RoutingTriggerOnType' 2133 options: 2134 $ref: '#/components/schemas/RoutingTriggerOptions' 2135 rewrite_to: 2136 type: string 2137 x-go-name: RewriteTo 2138 type: object 2139 x-go-package: github.com/TykTechnologies/tyk/apidef 2140 RoutingTriggerOnType: 2141 type: string 2142 x-go-package: github.com/TykTechnologies/tyk/apidef 2143 RoutingTriggerOptions: 2144 properties: 2145 header_matches: 2146 additionalProperties: 2147 $ref: '#/components/schemas/StringRegexMap' 2148 type: object 2149 x-go-name: HeaderMatches 2150 path_part_matches: 2151 additionalProperties: 2152 $ref: '#/components/schemas/StringRegexMap' 2153 type: object 2154 x-go-name: PathPartMatches 2155 payload_matches: 2156 $ref: '#/components/schemas/StringRegexMap' 2157 query_val_matches: 2158 additionalProperties: 2159 $ref: '#/components/schemas/StringRegexMap' 2160 type: object 2161 x-go-name: QueryValMatches 2162 request_context_matches: 2163 additionalProperties: 2164 $ref: '#/components/schemas/StringRegexMap' 2165 type: object 2166 x-go-name: RequestContextMatches 2167 session_meta_matches: 2168 additionalProperties: 2169 $ref: '#/components/schemas/StringRegexMap' 2170 type: object 2171 x-go-name: SessionMetaMatches 2172 type: object 2173 x-go-package: github.com/TykTechnologies/tyk/apidef 2174 ServiceDiscoveryConfiguration: 2175 properties: 2176 cache_timeout: 2177 format: int64 2178 type: integer 2179 x-go-name: CacheTimeout 2180 data_path: 2181 type: string 2182 x-go-name: DataPath 2183 endpoint_returns_list: 2184 type: boolean 2185 x-go-name: EndpointReturnsList 2186 parent_data_path: 2187 type: string 2188 x-go-name: ParentDataPath 2189 port_data_path: 2190 type: string 2191 x-go-name: PortDataPath 2192 query_endpoint: 2193 type: string 2194 x-go-name: QueryEndpoint 2195 target_path: 2196 type: string 2197 x-go-name: TargetPath 2198 use_discovery_service: 2199 type: boolean 2200 x-go-name: UseDiscoveryService 2201 use_nested_query: 2202 type: boolean 2203 x-go-name: UseNestedQuery 2204 use_target_list: 2205 type: boolean 2206 x-go-name: UseTargetList 2207 type: object 2208 x-go-package: github.com/TykTechnologies/tyk/apidef 2209 SessionProviderCode: 2210 type: string 2211 x-go-package: github.com/TykTechnologies/tyk/apidef 2212 SessionProviderMeta: 2213 properties: 2214 meta: 2215 additionalProperties: 2216 type: object 2217 type: object 2218 x-go-name: Meta 2219 name: 2220 $ref: '#/components/schemas/SessionProviderCode' 2221 storage_engine: 2222 $ref: '#/components/schemas/StorageEngineCode' 2223 type: object 2224 x-go-package: github.com/TykTechnologies/tyk/apidef 2225 SessionState: 2226 description: >- 2227 There's a data structure that's based on this and it's used for Protocol 2228 Buffer support, make sure to update 2229 "coprocess/proto/coprocess_session_state.proto" and generate the 2230 bindings using: cd coprocess/proto && ./update_bindings.sh 2231 properties: 2232 tags: 2233 items: 2234 type: string 2235 type: array 2236 x-go-name: Tags 2237 access_rights: 2238 additionalProperties: 2239 $ref: '#/components/schemas/AccessDefinition' 2240 type: object 2241 x-go-name: AccessRights 2242 alias: 2243 type: string 2244 x-go-name: Alias 2245 allowance: 2246 format: double 2247 type: number 2248 x-go-name: Allowance 2249 apply_policies: 2250 items: 2251 type: string 2252 type: array 2253 x-go-name: ApplyPolicies 2254 apply_policy_id: 2255 type: string 2256 x-go-name: ApplyPolicyID 2257 basic_auth_data: 2258 properties: 2259 hash_type: 2260 $ref: '#/components/schemas/HashType' 2261 password: 2262 type: string 2263 x-go-name: Password 2264 type: object 2265 x-go-name: BasicAuthData 2266 certificate: 2267 type: string 2268 x-go-name: Certificate 2269 data_expires: 2270 format: int64 2271 type: integer 2272 x-go-name: DataExpires 2273 enable_detail_recording: 2274 type: boolean 2275 x-go-name: EnableDetailedRecording 2276 expires: 2277 format: int64 2278 type: integer 2279 x-go-name: Expires 2280 hmac_enabled: 2281 type: boolean 2282 x-go-name: HMACEnabled 2283 hmac_string: 2284 type: string 2285 x-go-name: HmacSecret 2286 id_extractor_deadline: 2287 format: int64 2288 type: integer 2289 x-go-name: IdExtractorDeadline 2290 is_inactive: 2291 type: boolean 2292 x-go-name: IsInactive 2293 jwt_data: 2294 properties: 2295 secret: 2296 type: string 2297 x-go-name: Secret 2298 type: object 2299 x-go-name: JWTData 2300 last_check: 2301 format: int64 2302 type: integer 2303 x-go-name: LastCheck 2304 last_updated: 2305 type: string 2306 x-go-name: LastUpdated 2307 meta_data: 2308 additionalProperties: 2309 type: object 2310 type: object 2311 x-go-name: MetaData 2312 monitor: 2313 properties: 2314 trigger_limits: 2315 items: 2316 format: double 2317 type: number 2318 type: array 2319 x-go-name: TriggerLimits 2320 type: object 2321 x-go-name: Monitor 2322 oauth_client_id: 2323 type: string 2324 x-go-name: OauthClientID 2325 oauth_keys: 2326 additionalProperties: 2327 type: string 2328 type: object 2329 x-go-name: OauthKeys 2330 org_id: 2331 type: string 2332 x-go-name: OrgID 2333 per: 2334 format: double 2335 type: number 2336 x-go-name: Per 2337 quota_max: 2338 format: int64 2339 type: integer 2340 x-go-name: QuotaMax 2341 quota_remaining: 2342 format: int64 2343 type: integer 2344 x-go-name: QuotaRemaining 2345 quota_renewal_rate: 2346 format: int64 2347 type: integer 2348 x-go-name: QuotaRenewalRate 2349 quota_renews: 2350 format: int64 2351 type: integer 2352 x-go-name: QuotaRenews 2353 rate: 2354 format: double 2355 type: number 2356 x-go-name: Rate 2357 session_lifetime: 2358 format: int64 2359 type: integer 2360 x-go-name: SessionLifetime 2361 throttle_interval: 2362 format: double 2363 type: number 2364 x-go-name: ThrottleInterval 2365 throttle_retry_limit: 2366 format: int64 2367 type: integer 2368 x-go-name: ThrottleRetryLimit 2369 title: >- 2370 SessionState objects represent a current API session, mainly used for 2371 rate limiting. 2372 type: object 2373 x-go-package: github.com/TykTechnologies/tyk/user 2374 SignatureConfig: 2375 properties: 2376 algorithm: 2377 type: string 2378 x-go-name: Algorithm 2379 allowed_clock_skew: 2380 format: int64 2381 type: integer 2382 x-go-name: AllowedClockSkew 2383 error_code: 2384 format: int64 2385 type: integer 2386 x-go-name: ErrorCode 2387 error_message: 2388 type: string 2389 x-go-name: ErrorMessage 2390 header: 2391 type: string 2392 x-go-name: Header 2393 secret: 2394 type: string 2395 x-go-name: Secret 2396 type: object 2397 x-go-package: github.com/TykTechnologies/tyk/apidef 2398 StorageEngineCode: 2399 type: string 2400 x-go-package: github.com/TykTechnologies/tyk/apidef 2401 StringRegexMap: 2402 properties: 2403 match_rx: 2404 type: string 2405 x-go-name: MatchPattern 2406 reverse: 2407 type: boolean 2408 x-go-name: Reverse 2409 type: object 2410 x-go-package: github.com/TykTechnologies/tyk/apidef 2411 TemplateData: 2412 properties: 2413 enable_session: 2414 type: boolean 2415 x-go-name: EnableSession 2416 input_type: 2417 $ref: '#/components/schemas/RequestInputType' 2418 template_mode: 2419 $ref: '#/components/schemas/TemplateMode' 2420 template_source: 2421 type: string 2422 x-go-name: TemplateSource 2423 type: object 2424 x-go-package: github.com/TykTechnologies/tyk/apidef 2425 TemplateMeta: 2426 properties: 2427 method: 2428 type: string 2429 x-go-name: Method 2430 path: 2431 type: string 2432 x-go-name: Path 2433 template_data: 2434 $ref: '#/components/schemas/TemplateData' 2435 type: object 2436 x-go-package: github.com/TykTechnologies/tyk/apidef 2437 TemplateMode: 2438 type: string 2439 x-go-package: github.com/TykTechnologies/tyk/apidef 2440 TrackEndpointMeta: 2441 properties: 2442 method: 2443 type: string 2444 x-go-name: Method 2445 path: 2446 type: string 2447 x-go-name: Path 2448 type: object 2449 x-go-package: github.com/TykTechnologies/tyk/apidef 2450 TransformJQMeta: 2451 properties: 2452 filter: 2453 type: string 2454 x-go-name: Filter 2455 method: 2456 type: string 2457 x-go-name: Method 2458 path: 2459 type: string 2460 x-go-name: Path 2461 type: object 2462 x-go-package: github.com/TykTechnologies/tyk/apidef 2463 URLRewriteMeta: 2464 properties: 2465 MatchRegexp: 2466 $ref: '#/components/schemas/Regexp' 2467 match_pattern: 2468 type: string 2469 x-go-name: MatchPattern 2470 method: 2471 type: string 2472 x-go-name: Method 2473 path: 2474 type: string 2475 x-go-name: Path 2476 rewrite_to: 2477 type: string 2478 x-go-name: RewriteTo 2479 triggers: 2480 items: 2481 $ref: '#/components/schemas/RoutingTrigger' 2482 type: array 2483 x-go-name: Triggers 2484 type: object 2485 x-go-package: github.com/TykTechnologies/tyk/apidef 2486 ValidatePathMeta: 2487 properties: 2488 error_response_code: 2489 description: >- 2490 Allows override of default 422 Unprocessible Entity response code 2491 for validation errors. 2492 format: int64 2493 type: integer 2494 x-go-name: ErrorResponseCode 2495 method: 2496 type: string 2497 x-go-name: Method 2498 path: 2499 type: string 2500 x-go-name: Path 2501 schema: 2502 additionalProperties: 2503 type: object 2504 type: object 2505 x-go-name: Schema 2506 schema_b64: 2507 type: string 2508 x-go-name: SchemaB64 2509 type: object 2510 x-go-package: github.com/TykTechnologies/tyk/apidef 2511 VersionInfo: 2512 properties: 2513 paths: 2514 properties: 2515 black_list: 2516 items: 2517 type: string 2518 type: array 2519 x-go-name: BlackList 2520 ignored: 2521 items: 2522 type: string 2523 type: array 2524 x-go-name: Ignored 2525 white_list: 2526 items: 2527 type: string 2528 type: array 2529 x-go-name: WhiteList 2530 type: object 2531 x-go-name: Paths 2532 expires: 2533 type: string 2534 x-go-name: Expires 2535 extended_paths: 2536 $ref: '#/components/schemas/ExtendedPathsSet' 2537 global_headers: 2538 additionalProperties: 2539 type: string 2540 type: object 2541 x-go-name: GlobalHeaders 2542 global_headers_remove: 2543 items: 2544 type: string 2545 type: array 2546 x-go-name: GlobalHeadersRemove 2547 global_size_limit: 2548 format: int64 2549 type: integer 2550 x-go-name: GlobalSizeLimit 2551 name: 2552 type: string 2553 x-go-name: Name 2554 override_target: 2555 type: string 2556 x-go-name: OverrideTarget 2557 use_extended_paths: 2558 type: boolean 2559 x-go-name: UseExtendedPaths 2560 type: object 2561 x-go-package: github.com/TykTechnologies/tyk/apidef 2562 VirtualMeta: 2563 properties: 2564 function_source_type: 2565 type: string 2566 x-go-name: FunctionSourceType 2567 function_source_uri: 2568 type: string 2569 x-go-name: FunctionSourceURI 2570 method: 2571 type: string 2572 x-go-name: Method 2573 path: 2574 type: string 2575 x-go-name: Path 2576 proxy_on_error: 2577 type: boolean 2578 x-go-name: ProxyOnError 2579 response_function_name: 2580 type: string 2581 x-go-name: ResponseFunctionName 2582 use_session: 2583 type: boolean 2584 x-go-name: UseSession 2585 type: object 2586 x-go-package: github.com/TykTechnologies/tyk/apidef 2587 apiAllKeys: 2588 description: apiAllKeys represents a list of keys in the memory store 2589 properties: 2590 keys: 2591 items: 2592 type: string 2593 type: array 2594 x-go-name: APIKeys 2595 type: object 2596 x-go-package: github.com/TykTechnologies/tyk 2597 apiModifyKeySuccess: 2598 description: apiModifyKeySuccess represents when a Key modification was successful 2599 properties: 2600 action: 2601 type: string 2602 x-go-name: Action 2603 key: 2604 description: 'in:body' 2605 type: string 2606 x-go-name: Key 2607 key_hash: 2608 type: string 2609 x-go-name: KeyHash 2610 status: 2611 type: string 2612 x-go-name: Status 2613 type: object 2614 x-go-package: github.com/TykTechnologies/tyk 2615 apiStatusMessage: 2616 description: apiStatusMessage represents an API status message 2617 properties: 2618 message: 2619 description: Response details 2620 type: string 2621 x-go-name: Message 2622 status: 2623 type: string 2624 x-go-name: Status 2625 type: object 2626 x-go-package: github.com/TykTechnologies/tyk 2627 securitySchemes: 2628 api_key: 2629 in: header 2630 name: X-Tyk-Authorization 2631 type: apiKey 2632 security: 2633 - api_key: []