swagger

package
v0.0.0-...-ffeb61e Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Feb 12, 2025 License: Apache-2.0 Imports: 21 Imported by: 0

README

Go API client for swagger

The Tyk Gateway 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. Warning: Under no circumstances should outside parties be granted access to this API. The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the secret parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: x-tyk-authorization: <your-secret>
The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.

Overview

This API client was generated by the swagger-codegen project. By using the swagger-spec from a remote server, you can easily generate an API client.

  • API version: 5.5.0
  • Package version: 1.0.0
  • Build package: io.swagger.codegen.v3.generators.go.GoClientCodegen

Installation

Put the package under your project folder and add the following in import:

import "./swagger"

Documentation for API Endpoints

All URIs are relative to http://localhost/

Class Method HTTP request Description
APIsApi CreateApi Post /tyk/apis
APIsApi DeleteApi Delete /tyk/apis/{apiID}
APIsApi GetApi Get /tyk/apis/{apiID}
APIsApi ListApiVersions Get /tyk/apis/{apiID}/versions
APIsApi ListApis Get /tyk/apis
APIsApi UpdateApi Put /tyk/apis/{apiID}
BatchRequestsApi Batch Post /{listen_path}/tyk/batch Run batch request
CacheInvalidationApi InvalidateCache Delete /tyk/cache/{apiID} Invalidate cache
CertsApi AddCert Post /tyk/certs Add a certificate
CertsApi DeleteCerts Delete /tyk/certs Delete Certificate
CertsApi ListCerts Get /tyk/certs List Certificates
HealthCheckingApi Hello Get /tyk/hello Check the Health of the Tyk Gateway
HotReloadApi HotReload Get /tyk/reload/ Hot-reload a single node
HotReloadApi HotReloadGroup Get /tyk/reload/group Hot-reload a Tyk group
KeysApi AddKey Post /tyk/keys Create a key
KeysApi CreateCustomKey Post /tyk/keys/{keyID} Create Custom Key / Import Key
KeysApi DeleteKey Delete /tyk/keys/{keyID} Delete Key
KeysApi GetKey Get /tyk/keys/{keyID} Get a Key
KeysApi ListKeys Get /tyk/keys List Keys
KeysApi UpdateKey Put /tyk/keys/{keyID} Update Key
OASAPIsApi CreateApiOAS Post /tyk/apis/oas
OASAPIsApi DeleteOASApi Delete /tyk/apis/oas/{apiID}
OASAPIsApi DownloadApiOASPublic Get /tyk/apis/oas/{apiID}/export
OASAPIsApi DownloadApisOASPublic Get /tyk/apis/oas/export
OASAPIsApi ImportOAS Post /tyk/apis/oas/import
OASAPIsApi ListApiOAS Get /tyk/apis/oas/{apiID}
OASAPIsApi ListApisOAS Get /tyk/apis/oas
OASAPIsApi ListOASApiVersions Get /tyk/apis/oas/{apiID}/versions
OASAPIsApi PatchApiOAS Patch /tyk/apis/oas/{apiID} Patch a single OAS API by ID
OASAPIsApi UpdateApiOAS Put /tyk/apis/oas/{apiID}
OAuthApi AuthorizeClient Post /tyk/oauth/authorize-client/ Authorize client
OAuthApi CreateOAuthClient Post /tyk/oauth/clients/create Create new OAuth client
OAuthApi DeleteOAuthClient Delete /tyk/oauth/clients/{apiID}/{keyName} Delete OAuth client
OAuthApi GetOAuthClient Get /tyk/oauth/clients/{apiID}/{keyName} Get OAuth client
OAuthApi GetOAuthClientTokens Get /tyk/oauth/clients/{apiID}/{keyName}/tokens List tokens
OAuthApi InvalidateOAuthRefresh Delete /tyk/oauth/refresh/{keyName} Invalidate OAuth refresh token
OAuthApi ListOAuthClients Get /tyk/oauth/clients/{apiID} List oAuth clients
OAuthApi RevokeAllTokens Post /tyk/oauth/revoke_all revoke all client's tokens
OAuthApi RevokeSingleToken Post /tyk/oauth/revoke revoke token
OAuthApi UpdateoAuthClient Put /tyk/oauth/clients/{apiID} Update OAuth metadata and Policy ID
OrganisationQuotasApi AddOrgKey Post /tyk/org/keys/{keyID} Create an organisation key
OrganisationQuotasApi DeleteOrgKey Delete /tyk/org/keys/{keyID} Delete Organisation Key
OrganisationQuotasApi GetOrgKey Get /tyk/org/keys/{keyID} Get an Organisation Key
OrganisationQuotasApi ListOrgKeys Get /tyk/org/keys List Organisation Keys
OrganisationQuotasApi UpdateOrgKey Put /tyk/org/keys/{keyID} Update Organisation Key
PoliciesApi AddPolicy Post /tyk/policies Create a Policy
PoliciesApi DeletePolicy Delete /tyk/policies/{polID} Delete a Policy
PoliciesApi GetPolicy Get /tyk/policies/{polID} Get a Policy
PoliciesApi ListPolicies Get /tyk/policies List Policies
PoliciesApi UpdatePolicy Put /tyk/policies/{polID} Update a Policy
SchemaApi GetSchema Get /tyk/schema

Documentation For Models

Documentation For Authorization

api_key

  • Type: API key

Example

auth := context.WithValue(context.Background(), sw.ContextAPIKey, sw.APIKey{
	Key: "APIKEY",
	Prefix: "Bearer", // Omit if not necessary.
})
r, err := client.Service.Operation(auth, args)

Author

Documentation

Overview

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

* Tyk Gateway API * * The Tyk Gateway 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. **Warning: Under no circumstances should outside parties be granted access to this API.** The Tyk Gateway API is capable of: * Managing session objects (key generation) * Managing and listing policies * Managing and listing API Definitions (only when not using the Dashboard) * Hot reloads / reloading a cluster configuration * OAuth client creation (only when not using the Dashboard) In order to use the Gateway API, you'll need to set the `secret` parameter in your tyk.conf file. The shared secret you set should then be sent along as a header with each Gateway API Request in order for it to be successful: ``` x-tyk-authorization: <your-secret> ``` <br/> <b>The Tyk Gateway API is subsumed by the Tyk Dashboard API in Pro installations.</b> * * API version: 5.5.0 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)

Index

Constants

This section is empty.

Variables

View Source
var (
	// ContextOAuth2 takes a oauth2.TokenSource as authentication for the request.
	ContextOAuth2 = contextKey("token")

	// ContextBasicAuth takes BasicAuth as authentication for the request.
	ContextBasicAuth = contextKey("basic")

	// ContextAccessToken takes a string oauth2 access token as authentication for the request.
	ContextAccessToken = contextKey("accesstoken")

	// ContextAPIKey takes an APIKey as authentication for the request
	ContextAPIKey = contextKey("apikey")
)

Functions

func CacheExpires

func CacheExpires(r *http.Response) time.Time

CacheExpires helper function to determine remaining time before repeating a request.

Types

type APIClient

type APIClient struct {
	APIsApi *APIsApiService

	BatchRequestsApi *BatchRequestsApiService

	CacheInvalidationApi *CacheInvalidationApiService

	CertsApi *CertsApiService

	HealthCheckingApi *HealthCheckingApiService

	HotReloadApi *HotReloadApiService

	KeysApi *KeysApiService

	OASAPIsApi *OASAPIsApiService

	OAuthApi *OAuthApiService

	OrganisationQuotasApi *OrganisationQuotasApiService

	PoliciesApi *PoliciesApiService

	SchemaApi *SchemaApiService
	// contains filtered or unexported fields
}

APIClient manages communication with the Tyk Gateway API API v5.5.0 In most cases there should be only one, shared, APIClient.

func NewAPIClient

func NewAPIClient(cfg *Configuration) *APIClient

NewAPIClient creates a new API client. Requires a userAgent string describing your application. optionally a custom http.Client to allow for advanced features such as caching.

func (*APIClient) ChangeBasePath

func (c *APIClient) ChangeBasePath(path string)

Change base path to allow switching to mocks

type APIKey

type APIKey struct {
	Key    string
	Prefix string
}

APIKey provides API key based authentication to a request passed via context using ContextAPIKey

type APIResponse

type APIResponse struct {
	*http.Response `json:"-"`
	Message        string `json:"message,omitempty"`
	// Operation is the name of the swagger operation.
	Operation string `json:"operation,omitempty"`
	// RequestURL is the request URL. This value is always available, even if the
	// embedded *http.Response is nil.
	RequestURL string `json:"url,omitempty"`
	// Method is the HTTP method used for the request.  This value is always
	// available, even if the embedded *http.Response is nil.
	Method string `json:"method,omitempty"`
	// Payload holds the contents of the response body (which may be nil or empty).
	// This is provided here as the raw response.Body() reader will have already
	// been drained.
	Payload []byte `json:"-"`
}

func NewAPIResponse

func NewAPIResponse(r *http.Response) *APIResponse

func NewAPIResponseWithError

func NewAPIResponseWithError(errorMessage string) *APIResponse

type APIsApiCreateApiOpts

type APIsApiCreateApiOpts struct {
	Body               optional.Interface
	BaseApiId          optional.String
	BaseApiVersionName optional.String
	NewVersionName     optional.String
	SetDefault         optional.Bool
}

type APIsApiListApiVersionsOpts

type APIsApiListApiVersionsOpts struct {
	SearchText optional.String
	AccessType optional.String
}

type APIsApiService

type APIsApiService service

func (*APIsApiService) CreateApi

func (a *APIsApiService) CreateApi(ctx context.Context, localVarOptionals *APIsApiCreateApiOpts) (ApiModifyKeySuccess, *http.Response, error)

func (*APIsApiService) DeleteApi

func (a *APIsApiService) DeleteApi(ctx context.Context, apiID string) (ApiStatusMessage, *http.Response, error)

APIsApiService 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.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param apiID The API ID

@return ApiStatusMessage

func (*APIsApiService) GetApi

func (a *APIsApiService) GetApi(ctx context.Context, apiID string) (ApiDefinition, *http.Response, error)

APIsApiService Get API definition Only if used without the Tyk Dashboard

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param apiID The API ID

@return ApiDefinition

func (*APIsApiService) ListApiVersions

func (a *APIsApiService) ListApiVersions(ctx context.Context, apiID string, localVarOptionals *APIsApiListApiVersionsOpts) (InlineResponse200, *http.Response, error)

func (*APIsApiService) ListApis

func (a *APIsApiService) ListApis(ctx context.Context) ([]ApiDefinition, *http.Response, error)

APIsApiService List APIs Only if used without the Tyk Dashboard

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return []ApiDefinition

func (*APIsApiService) UpdateApi

func (a *APIsApiService) UpdateApi(ctx context.Context, apiID string, localVarOptionals *APIsApiUpdateApiOpts) (ApiModifyKeySuccess, *http.Response, error)

type APIsApiUpdateApiOpts

type APIsApiUpdateApiOpts struct {
	Body optional.Interface
}

type AccessDefinition

type AccessDefinition struct {
	AllowedUrls []AccessSpec `json:"allowed_urls,omitempty"`
	ApiId       string       `json:"api_id,omitempty"`
	ApiName     string       `json:"api_name,omitempty"`
	Limit       *ApiLimit    `json:"limit,omitempty"`
	Versions    []string     `json:"versions,omitempty"`
}

AccessDefinition defines which versions of an API a key has access to

type AccessSpec

type AccessSpec struct {
	Methods []string `json:"methods,omitempty"`
	Url     string   `json:"url,omitempty"`
}

AccessSpecs define what URLS a user has access to an what methods are enabled

type ApiAllCertificateBasics

type ApiAllCertificateBasics struct {
	Certs []CertificateBasics `json:"certs,omitempty"`
}

APIAllCertificates represents a list of certificate basics

type ApiAllCertificates

type ApiAllCertificates struct {
	Certs []string `json:"certs,omitempty"`
}

APIAllCertificates represents a list of certificates

type ApiAllKeys

type ApiAllKeys struct {
	Keys []string `json:"keys,omitempty"`
}

apiAllKeys represents a list of keys in the memory store

type ApiCertificateStatusMessage

type ApiCertificateStatusMessage struct {
	Id      string `json:"id,omitempty"`
	Status  string `json:"status,omitempty"`
	Message string `json:"message,omitempty"`
}

Status message when certificate is added

type ApiDefinition

type ApiDefinition struct {
	Tags                       []string                  `json:"tags,omitempty"`
	CORS                       *ApiDefinitionCors        `json:"CORS,omitempty"`
	Active                     bool                      `json:"active,omitempty"`
	AllowedIps                 []string                  `json:"allowed_ips,omitempty"`
	ApiId                      string                    `json:"api_id,omitempty"`
	Auth                       *Auth                     `json:"auth,omitempty"`
	AuthProvider               *AuthProviderMeta         `json:"auth_provider,omitempty"`
	BaseIdentityProvidedBy     string                    `json:"base_identity_provided_by,omitempty"`
	BasicAuth                  *ApiDefinitionBasicAuth   `json:"basic_auth,omitempty"`
	BlacklistedIps             []string                  `json:"blacklisted_ips,omitempty"`
	CacheOptions               *CacheOptions             `json:"cache_options,omitempty"`
	Certificates               []string                  `json:"certificates,omitempty"`
	ClientCertificates         []string                  `json:"client_certificates,omitempty"`
	ConfigData                 map[string]interface{}    `json:"config_data,omitempty"`
	CustomMiddleware           *MiddlewareSection        `json:"custom_middleware,omitempty"`
	CustomMiddlewareBundle     string                    `json:"custom_middleware_bundle,omitempty"`
	Definition                 *ApiDefinitionDefinition  `json:"definition,omitempty"`
	DisableQuota               bool                      `json:"disable_quota,omitempty"`
	DisableRateLimit           bool                      `json:"disable_rate_limit,omitempty"`
	DoNotTrack                 bool                      `json:"do_not_track,omitempty"`
	Domain                     string                    `json:"domain,omitempty"`
	DontSetQuotaOnCreate       bool                      `json:"dont_set_quota_on_create,omitempty"`
	EnableBatchRequestSupport  bool                      `json:"enable_batch_request_support,omitempty"`
	EnableContextVars          bool                      `json:"enable_context_vars,omitempty"`
	EnableCoprocessAuth        bool                      `json:"enable_coprocess_auth,omitempty"`
	EnableIpBlacklisting       bool                      `json:"enable_ip_blacklisting,omitempty"`
	EnableIpWhitelisting       bool                      `json:"enable_ip_whitelisting,omitempty"`
	EnableJwt                  bool                      `json:"enable_jwt,omitempty"`
	EnableSignatureChecking    bool                      `json:"enable_signature_checking,omitempty"`
	EventHandlers              *EventHandlerMetaConfig   `json:"event_handlers,omitempty"`
	ExpireAnalyticsAfter       int64                     `json:"expire_analytics_after,omitempty"`
	GlobalRateLimit            *GlobalRateLimit          `json:"global_rate_limit,omitempty"`
	HmacAllowedAlgorithms      []string                  `json:"hmac_allowed_algorithms,omitempty"`
	HmacAllowedClockSkew       float64                   `json:"hmac_allowed_clock_skew,omitempty"`
	Id                         string                    `json:"id,omitempty"`
	Internal                   bool                      `json:"internal,omitempty"`
	JwtClientBaseField         string                    `json:"jwt_client_base_field,omitempty"`
	JwtExpiresAtValidationSkew int32                     `json:"jwt_expires_at_validation_skew,omitempty"`
	JwtIdentityBaseField       string                    `json:"jwt_identity_base_field,omitempty"`
	JwtIssuedAtValidationSkew  int32                     `json:"jwt_issued_at_validation_skew,omitempty"`
	JwtNotBeforeValidationSkew int32                     `json:"jwt_not_before_validation_skew,omitempty"`
	JwtPolicyFieldName         string                    `json:"jwt_policy_field_name,omitempty"`
	JwtScopeClaimName          string                    `json:"jwt_scope_claim_name,omitempty"`
	JwtScopeToPolicyMapping    map[string]string         `json:"jwt_scope_to_policy_mapping,omitempty"`
	JwtSigningMethod           string                    `json:"jwt_signing_method,omitempty"`
	JwtSkipKid                 bool                      `json:"jwt_skip_kid,omitempty"`
	JwtSource                  string                    `json:"jwt_source,omitempty"`
	Name                       string                    `json:"name,omitempty"`
	Notifications              *NotificationsManager     `json:"notifications,omitempty"`
	OauthMeta                  *ApiDefinitionOauthMeta   `json:"oauth_meta,omitempty"`
	OpenidOptions              *OpenIdOptions            `json:"openid_options,omitempty"`
	OrgId                      string                    `json:"org_id,omitempty"`
	PinnedPublicKeys           map[string]string         `json:"pinned_public_keys,omitempty"`
	Proxy                      *ApiDefinitionProxy       `json:"proxy,omitempty"`
	ResponseProcessors         []ResponseProcessor       `json:"response_processors,omitempty"`
	SessionLifetime            int64                     `json:"session_lifetime,omitempty"`
	SessionProvider            *SessionProviderMeta      `json:"session_provider,omitempty"`
	Slug                       string                    `json:"slug,omitempty"`
	StripAuthData              bool                      `json:"strip_auth_data,omitempty"`
	TagHeaders                 []string                  `json:"tag_headers,omitempty"`
	UpstreamCertificates       map[string]string         `json:"upstream_certificates,omitempty"`
	UptimeTests                *ApiDefinitionUptimeTests `json:"uptime_tests,omitempty"`
	UseBasicAuth               bool                      `json:"use_basic_auth,omitempty"`
	UseKeyless                 bool                      `json:"use_keyless,omitempty"`
	UseMutualTlsAuth           bool                      `json:"use_mutual_tls_auth,omitempty"`
	UseOauth2                  bool                      `json:"use_oauth2,omitempty"`
	UseOpenid                  bool                      `json:"use_openid,omitempty"`
	UseStandardAuth            bool                      `json:"use_standard_auth,omitempty"`
	VersionData                *ApiDefinitionVersionData `json:"version_data,omitempty"`
}

type ApiDefinitionBasicAuth

type ApiDefinitionBasicAuth struct {
	BodyPasswordRegexp string `json:"body_password_regexp,omitempty"`
	BodyUserRegexp     string `json:"body_user_regexp,omitempty"`
	CacheTtl           int64  `json:"cache_ttl,omitempty"`
	DisableCaching     bool   `json:"disable_caching,omitempty"`
	ExtractFromBody    bool   `json:"extract_from_body,omitempty"`
}

type ApiDefinitionCors

type ApiDefinitionCors struct {
	AllowCredentials   bool     `json:"allow_credentials,omitempty"`
	AllowedHeaders     []string `json:"allowed_headers,omitempty"`
	AllowedMethods     []string `json:"allowed_methods,omitempty"`
	AllowedOrigins     []string `json:"allowed_origins,omitempty"`
	Debug              bool     `json:"debug,omitempty"`
	Enable             bool     `json:"enable,omitempty"`
	ExposedHeaders     []string `json:"exposed_headers,omitempty"`
	MaxAge             int64    `json:"max_age,omitempty"`
	OptionsPassthrough bool     `json:"options_passthrough,omitempty"`
}

type ApiDefinitionDefinition

type ApiDefinitionDefinition struct {
	Key       string `json:"key,omitempty"`
	Location  string `json:"location,omitempty"`
	StripPath bool   `json:"strip_path,omitempty"`
}

type ApiDefinitionOauthMeta

type ApiDefinitionOauthMeta struct {
	AllowedAccessTypes    []string `json:"allowed_access_types,omitempty"`
	AllowedAuthorizeTypes []string `json:"allowed_authorize_types,omitempty"`
	AuthLoginRedirect     string   `json:"auth_login_redirect,omitempty"`
}

type ApiDefinitionProxy

type ApiDefinitionProxy struct {
	CheckHostAgainstUptimeTests bool                           `json:"check_host_against_uptime_tests,omitempty"`
	DisableStripSlash           bool                           `json:"disable_strip_slash,omitempty"`
	EnableLoadBalancing         bool                           `json:"enable_load_balancing,omitempty"`
	ListenPath                  string                         `json:"listen_path,omitempty"`
	PreserveHostHeader          bool                           `json:"preserve_host_header,omitempty"`
	ServiceDiscovery            *ServiceDiscoveryConfiguration `json:"service_discovery,omitempty"`
	StripListenPath             bool                           `json:"strip_listen_path,omitempty"`
	TargetList                  []string                       `json:"target_list,omitempty"`
	TargetUrl                   string                         `json:"target_url,omitempty"`
	Transport                   *ApiDefinitionProxyTransport   `json:"transport,omitempty"`
}

type ApiDefinitionProxyTransport

type ApiDefinitionProxyTransport struct {
	ProxyUrl              string   `json:"proxy_url,omitempty"`
	SslCiphers            []string `json:"ssl_ciphers,omitempty"`
	SslInsecureSkipVerify bool     `json:"ssl_insecure_skip_verify,omitempty"`
	SslMinVersion         int32    `json:"ssl_min_version,omitempty"`
}

type ApiDefinitionUptimeTests

type ApiDefinitionUptimeTests struct {
	CheckList []HostCheckObject               `json:"check_list,omitempty"`
	Config    *ApiDefinitionUptimeTestsConfig `json:"config,omitempty"`
}

type ApiDefinitionUptimeTestsConfig

type ApiDefinitionUptimeTestsConfig struct {
	ExpireUtimeAfter int64                          `json:"expire_utime_after,omitempty"`
	RecheckWait      int64                          `json:"recheck_wait,omitempty"`
	ServiceDiscovery *ServiceDiscoveryConfiguration `json:"service_discovery,omitempty"`
}

type ApiDefinitionVersionData

type ApiDefinitionVersionData struct {
	DefaultVersion string                 `json:"default_version,omitempty"`
	NotVersioned   bool                   `json:"not_versioned,omitempty"`
	Versions       map[string]VersionInfo `json:"versions,omitempty"`
}

type ApiLimit

type ApiLimit struct {
	Per                float64             `json:"per,omitempty"`
	QuotaMax           int64               `json:"quota_max,omitempty"`
	QuotaRemaining     int64               `json:"quota_remaining,omitempty"`
	QuotaRenewalRate   int64               `json:"quota_renewal_rate,omitempty"`
	QuotaRenews        int64               `json:"quota_renews,omitempty"`
	Rate               float64             `json:"rate,omitempty"`
	SetByPolicy        bool                `json:"set_by_policy,omitempty"`
	ThrottleInterval   float64             `json:"throttle_interval,omitempty"`
	ThrottleRetryLimit int64               `json:"throttle_retry_limit,omitempty"`
	Smoothing          *RateLimitSmoothing `json:"smoothing,omitempty"`
}

type ApiModifyKeySuccess

type ApiModifyKeySuccess struct {
	Action string `json:"action,omitempty"`
	// in:body
	Key     string `json:"key,omitempty"`
	KeyHash string `json:"key_hash,omitempty"`
	Status  string `json:"status,omitempty"`
}

apiModifyKeySuccess represents when a Key modification was successful

type ApiStatusMessage

type ApiStatusMessage struct {
	// Response details
	Message string `json:"message,omitempty"`
	Status  string `json:"status,omitempty"`
}

apiStatusMessage represents an API status message

type ApiVersionMeta

type ApiVersionMeta struct {
	Id               string `json:"id,omitempty"`
	Name             string `json:"name,omitempty"`
	VersionName      string `json:"versionName,omitempty"`
	Internal         bool   `json:"internal,omitempty"`
	ExpirationDate   string `json:"expirationDate,omitempty"`
	IsDefaultVersion bool   `json:"isDefaultVersion,omitempty"`
}

API version meta

type Auth

type Auth struct {
	AuthHeaderName    string           `json:"auth_header_name,omitempty"`
	CookieName        string           `json:"cookie_name,omitempty"`
	ParamName         string           `json:"param_name,omitempty"`
	Signature         *SignatureConfig `json:"signature,omitempty"`
	UseCertificate    bool             `json:"use_certificate,omitempty"`
	UseCookie         bool             `json:"use_cookie,omitempty"`
	UseParam          bool             `json:"use_param,omitempty"`
	ValidateSignature bool             `json:"validate_signature,omitempty"`
}

type AuthProviderMeta

type AuthProviderMeta struct {
	Meta          map[string]interface{} `json:"meta,omitempty"`
	Name          string                 `json:"name,omitempty"`
	StorageEngine string                 `json:"storage_engine,omitempty"`
}

type BasicAuth

type BasicAuth struct {
	UserName string `json:"userName,omitempty"`
	Password string `json:"password,omitempty"`
}

BasicAuth provides basic http authentication to a request passed via context using ContextBasicAuth

type BatchRequestsApiService

type BatchRequestsApiService service

func (*BatchRequestsApiService) Batch

BatchRequestsApiService Run batch request

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param listenPath API listen path

@return ApiStatusMessage

type BooleanQueryParam

type BooleanQueryParam string
const (
	TRUE_BooleanQueryParam  BooleanQueryParam = "true"
	FALSE_BooleanQueryParam BooleanQueryParam = "false"
)

List of BooleanQueryParam

type CacheInvalidationApiService

type CacheInvalidationApiService service

func (*CacheInvalidationApiService) InvalidateCache

CacheInvalidationApiService Invalidate cache Invalidate cache for the given API

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param apiID The API ID

@return ApiStatusMessage

type CacheMeta

type CacheMeta struct {
	CacheResponseCodes []int64 `json:"cache_response_codes,omitempty"`
	CacheKeyRegex      string  `json:"cache_key_regex,omitempty"`
	Method             string  `json:"method,omitempty"`
	Path               string  `json:"path,omitempty"`
}

type CacheOptions

type CacheOptions struct {
	CacheAllSafeRequests       bool    `json:"cache_all_safe_requests,omitempty"`
	CacheControlTtlHeader      string  `json:"cache_control_ttl_header,omitempty"`
	CacheResponseCodes         []int64 `json:"cache_response_codes,omitempty"`
	CacheTimeout               int64   `json:"cache_timeout,omitempty"`
	EnableCache                bool    `json:"enable_cache,omitempty"`
	EnableUpstreamCacheControl bool    `json:"enable_upstream_cache_control,omitempty"`
}

type CertificateBasics

type CertificateBasics struct {
	Id         string   `json:"id,omitempty"`
	IssuerCn   string   `json:"issuer_cn,omitempty"`
	SubjectCn  string   `json:"subject_cn,omitempty"`
	DnsNames   []string `json:"dns_names,omitempty"`
	HasPrivate string   `json:"has_private,omitempty"`
	NotBefore  string   `json:"not_before,omitempty"`
	NotAfter   string   `json:"not_after,omitempty"`
	IsCa       bool     `json:"is_ca,omitempty"`
}

CertificateBasics represents basic details of a certificate

type CertificateMeta

type CertificateMeta struct {
	Id          string    `json:"id,omitempty"`
	Fingerprint string    `json:"fingerprint,omitempty"`
	HasPrivate  string    `json:"has_private,omitempty"`
	Issuer      *PkixName `json:"issuer,omitempty"`
	Subject     *PkixName `json:"subject,omitempty"`
	NotBefore   string    `json:"not_before,omitempty"`
	NotAfter    string    `json:"not_after,omitempty"`
	DnsNames    []string  `json:"dns_names,omitempty"`
	IsCa        bool      `json:"is_ca,omitempty"`
}

CertificateBasics represents basic details of a certificate

type CertsApiAddCertOpts

type CertsApiAddCertOpts struct {
	Body optional.Interface
}

type CertsApiListCertsOpts

type CertsApiListCertsOpts struct {
	Mode   optional.String
	CertID optional.String
}

type CertsApiService

type CertsApiService service

func (*CertsApiService) AddCert

func (*CertsApiService) DeleteCerts

func (a *CertsApiService) DeleteCerts(ctx context.Context, certID string, orgId string) (ApiStatusMessage, *http.Response, error)

CertsApiService Delete Certificate Delete certificate by id

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param certID Certifiicate ID to be deleted
  • @param orgId Organisation ID to list the certificates

@return ApiStatusMessage

func (*CertsApiService) ListCerts

func (a *CertsApiService) ListCerts(ctx context.Context, orgId string, localVarOptionals *CertsApiListCertsOpts) (InlineResponse2001, *http.Response, error)

type CircuitBreakerMeta

type CircuitBreakerMeta struct {
	Method               string  `json:"method,omitempty"`
	Path                 string  `json:"path,omitempty"`
	ReturnToServiceAfter int64   `json:"return_to_service_after,omitempty"`
	Samples              int64   `json:"samples,omitempty"`
	ThresholdPercent     float64 `json:"threshold_percent,omitempty"`
}

type Components

type Components struct {
	Schemas         *interface{} `json:"schemas,omitempty"`
	Responses       *interface{} `json:"responses,omitempty"`
	Parameters      *interface{} `json:"parameters,omitempty"`
	Examples        *interface{} `json:"examples,omitempty"`
	RequestBodies   *interface{} `json:"requestBodies,omitempty"`
	Headers         *interface{} `json:"headers,omitempty"`
	SecuritySchemes *interface{} `json:"securitySchemes,omitempty"`
	Links           *interface{} `json:"links,omitempty"`
	Callbacks       *interface{} `json:"callbacks,omitempty"`
}

type Configuration

type Configuration struct {
	BasePath      string            `json:"basePath,omitempty"`
	Host          string            `json:"host,omitempty"`
	Scheme        string            `json:"scheme,omitempty"`
	DefaultHeader map[string]string `json:"defaultHeader,omitempty"`
	UserAgent     string            `json:"userAgent,omitempty"`
	HTTPClient    *http.Client
}

func NewConfiguration

func NewConfiguration() *Configuration

func (*Configuration) AddDefaultHeader

func (c *Configuration) AddDefaultHeader(key string, value string)

type Contact

type Contact struct {
	Name  string `json:"name,omitempty"`
	Url   string `json:"url,omitempty"`
	Email string `json:"email,omitempty"`
}

type EndPointMeta

type EndPointMeta struct {
	MethodActions map[string]EndpointMethodMeta `json:"method_actions,omitempty"`
	Path          string                        `json:"path,omitempty"`
}

type EndpointMethodMeta

type EndpointMethodMeta struct {
	Action  string            `json:"action,omitempty"`
	Code    int64             `json:"code,omitempty"`
	Data    string            `json:"data,omitempty"`
	Headers map[string]string `json:"headers,omitempty"`
}

type EventHandlerMetaConfig

type EventHandlerMetaConfig struct {
	Events *Object `json:"events,omitempty"`
}

type ExtendedPathsSet

type ExtendedPathsSet struct {
	AdvanceCacheConfig       []CacheMeta           `json:"advance_cache_config,omitempty"`
	BlackList                []EndPointMeta        `json:"black_list,omitempty"`
	Cache                    []string              `json:"cache,omitempty"`
	CircuitBreakers          []CircuitBreakerMeta  `json:"circuit_breakers,omitempty"`
	DoNotTrackEndpoints      []TrackEndpointMeta   `json:"do_not_track_endpoints,omitempty"`
	HardTimeouts             []HardTimeoutMeta     `json:"hard_timeouts,omitempty"`
	Ignored                  []EndPointMeta        `json:"ignored,omitempty"`
	Internal                 []InternalMeta        `json:"internal,omitempty"`
	MethodTransforms         []MethodTransformMeta `json:"method_transforms,omitempty"`
	RateLimit                []RateLimitMeta       `json:"rate_limit,omitempty"`
	SizeLimits               []RequestSizeMeta     `json:"size_limits,omitempty"`
	TrackEndpoints           []TrackEndpointMeta   `json:"track_endpoints,omitempty"`
	Transform                []TemplateMeta        `json:"transform,omitempty"`
	TransformHeaders         []HeaderInjectionMeta `json:"transform_headers,omitempty"`
	TransformJq              []TransformJqMeta     `json:"transform_jq,omitempty"`
	TransformJqResponse      []TransformJqMeta     `json:"transform_jq_response,omitempty"`
	TransformResponse        []TemplateMeta        `json:"transform_response,omitempty"`
	TransformResponseHeaders []HeaderInjectionMeta `json:"transform_response_headers,omitempty"`
	UrlRewrites              []UrlRewriteMeta      `json:"url_rewrites,omitempty"`
	ValidateJson             []ValidatePathMeta    `json:"validate_json,omitempty"`
	Virtual                  []VirtualMeta         `json:"virtual,omitempty"`
	WhiteList                []EndPointMeta        `json:"white_list,omitempty"`
}

type ExternalDocumentation

type ExternalDocumentation struct {
	Description string `json:"description,omitempty"`
	Url         string `json:"url"`
}

type GenericSwaggerError

type GenericSwaggerError struct {
	// contains filtered or unexported fields
}

GenericSwaggerError Provides access to the body, error and model on returned errors.

func (GenericSwaggerError) Body

func (e GenericSwaggerError) Body() []byte

Body returns the raw bytes of the response

func (GenericSwaggerError) Error

func (e GenericSwaggerError) Error() string

Error returns non-empty string if there was an error.

func (GenericSwaggerError) Model

func (e GenericSwaggerError) Model() interface{}

Model returns the unpacked model of the error

type GlobalRateLimit

type GlobalRateLimit struct {
	Per  float64 `json:"per,omitempty"`
	Rate float64 `json:"rate,omitempty"`
}

type GraphAccessDefinition

type GraphAccessDefinition struct {
}

type HardTimeoutMeta

type HardTimeoutMeta struct {
	Method  string `json:"method,omitempty"`
	Path    string `json:"path,omitempty"`
	Timeout int64  `json:"timeout,omitempty"`
}

type HeaderInjectionMeta

type HeaderInjectionMeta struct {
	ActOn         bool              `json:"act_on,omitempty"`
	AddHeaders    map[string]string `json:"add_headers,omitempty"`
	DeleteHeaders []string          `json:"delete_headers,omitempty"`
	Method        string            `json:"method,omitempty"`
	Path          string            `json:"path,omitempty"`
}

type HealthCheckingApiService

type HealthCheckingApiService service

func (*HealthCheckingApiService) Hello

HealthCheckingApiService Check the Health of the Tyk Gateway From v2.7.5 you can now rename the &#x60;/hello&#x60; endpoint by using the &#x60;health_check_endpoint_name&#x60; option Returns 200 response in case of success

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return string

type HostCheckObject

type HostCheckObject struct {
	Body    string            `json:"body,omitempty"`
	Headers map[string]string `json:"headers,omitempty"`
	Method  string            `json:"method,omitempty"`
	Url     string            `json:"url,omitempty"`
}

type HotReloadApiHotReloadOpts

type HotReloadApiHotReloadOpts struct {
	Block optional.Bool
}

type HotReloadApiService

type HotReloadApiService service

func (*HotReloadApiService) HotReload

func (*HotReloadApiService) HotReloadGroup

HotReloadApiService Hot-reload a Tyk group 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.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return ApiStatusMessage

type Info

type Info struct {
	Title          string   `json:"title"`
	Description    string   `json:"description,omitempty"`
	TermsOfService string   `json:"termsOfService,omitempty"`
	Contact        *Contact `json:"contact,omitempty"`
	License        *License `json:"license,omitempty"`
	Version        string   `json:"version"`
}

type InlineResponse200

type InlineResponse200 struct {
	Apis []ApiVersionMeta `json:"apis,omitempty"`
}

type InlineResponse2001

type InlineResponse2001 struct {
	ApiAllCertificates
	ApiAllCertificateBasics
}

type InlineResponse2002

type InlineResponse2002 struct {
	Keys []string `json:"keys,omitempty"`
}

type InternalMeta

type InternalMeta struct {
	Method string `json:"method,omitempty"`
	Path   string `json:"path,omitempty"`
}

type KeysApiAddKeyOpts

type KeysApiAddKeyOpts struct {
	Body optional.Interface
}

type KeysApiCreateCustomKeyOpts

type KeysApiCreateCustomKeyOpts struct {
	Body          optional.Interface
	Hashed        optional.Bool
	SuppressReset optional.String
}

type KeysApiDeleteKeyOpts

type KeysApiDeleteKeyOpts struct {
	Hashed optional.Bool
}

type KeysApiGetKeyOpts

type KeysApiGetKeyOpts struct {
	Hashed optional.Bool
}

type KeysApiService

type KeysApiService service

func (*KeysApiService) AddKey

func (a *KeysApiService) AddKey(ctx context.Context, localVarOptionals *KeysApiAddKeyOpts) (ApiModifyKeySuccess, *http.Response, error)

func (*KeysApiService) CreateCustomKey

func (a *KeysApiService) CreateCustomKey(ctx context.Context, keyID string, localVarOptionals *KeysApiCreateCustomKeyOpts) (ApiModifyKeySuccess, *http.Response, error)

func (*KeysApiService) DeleteKey

func (a *KeysApiService) DeleteKey(ctx context.Context, keyID string, localVarOptionals *KeysApiDeleteKeyOpts) (ApiStatusMessage, *http.Response, error)

func (*KeysApiService) GetKey

func (a *KeysApiService) GetKey(ctx context.Context, keyID string, localVarOptionals *KeysApiGetKeyOpts) (SessionState, *http.Response, error)

func (*KeysApiService) ListKeys

func (a *KeysApiService) ListKeys(ctx context.Context) (ApiAllKeys, *http.Response, error)

KeysApiService List Keys You can retrieve all the keys in your Tyk instance. Returns an array of Key IDs.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return ApiAllKeys

func (*KeysApiService) UpdateKey

func (a *KeysApiService) UpdateKey(ctx context.Context, keyID string, localVarOptionals *KeysApiUpdateKeyOpts) (ApiModifyKeySuccess, *http.Response, error)

type KeysApiUpdateKeyOpts

type KeysApiUpdateKeyOpts struct {
	Body          optional.Interface
	Hashed        optional.Bool
	SuppressReset optional.String
}

type License

type License struct {
	Name string `json:"name"`
	Url  string `json:"url,omitempty"`
}

type MethodTransformMeta

type MethodTransformMeta struct {
	Method   string `json:"method,omitempty"`
	Path     string `json:"path,omitempty"`
	ToMethod string `json:"to_method,omitempty"`
}

type MiddlewareDefinition

type MiddlewareDefinition struct {
	Name           string `json:"name,omitempty"`
	Path           string `json:"path,omitempty"`
	RequireSession bool   `json:"require_session,omitempty"`
}

type MiddlewareIdExtractor

type MiddlewareIdExtractor struct {
	ExtractFrom     string                 `json:"extract_from,omitempty"`
	ExtractWith     string                 `json:"extract_with,omitempty"`
	ExtractorConfig map[string]interface{} `json:"extractor_config,omitempty"`
}

type MiddlewareSection

type MiddlewareSection struct {
	AuthCheck   *MiddlewareDefinition  `json:"auth_check,omitempty"`
	Driver      string                 `json:"driver,omitempty"`
	IdExtractor *MiddlewareIdExtractor `json:"id_extractor,omitempty"`
	Post        []MiddlewareDefinition `json:"post,omitempty"`
	PostKeyAuth []MiddlewareDefinition `json:"post_key_auth,omitempty"`
	Pre         []MiddlewareDefinition `json:"pre,omitempty"`
	Response    []MiddlewareDefinition `json:"response,omitempty"`
}

type NewClientRequest

type NewClientRequest struct {
	ApiId       string       `json:"api_id,omitempty"`
	ClientId    string       `json:"client_id,omitempty"`
	Description string       `json:"description,omitempty"`
	MetaData    *interface{} `json:"meta_data,omitempty"`
	PolicyId    string       `json:"policy_id,omitempty"`
	RedirectUri string       `json:"redirect_uri,omitempty"`
	Secret      string       `json:"secret,omitempty"`
}

NewClientRequest is an outward facing JSON object translated from osin OAuthClients

type NotificationsManager

type NotificationsManager struct {
	OauthOnKeychangeUrl string `json:"oauth_on_keychange_url,omitempty"`
	SharedSecret        string `json:"shared_secret,omitempty"`
}

TODO: Make this more generic

type OASAPIsApiCreateApiOASOpts

type OASAPIsApiCreateApiOASOpts struct {
	Body               optional.Interface
	BaseApiId          optional.String
	BaseApiVersionName optional.String
	NewVersionName     optional.String
	SetDefault         optional.Bool
}

type OASAPIsApiDownloadApiOASPublicOpts

type OASAPIsApiDownloadApiOASPublicOpts struct {
	Mode optional.String
}

type OASAPIsApiDownloadApisOASPublicOpts

type OASAPIsApiDownloadApisOASPublicOpts struct {
	Mode optional.String
}

type OASAPIsApiImportOASOpts

type OASAPIsApiImportOASOpts struct {
	Body            optional.Interface
	UpstreamURL     optional.String
	ListenPath      optional.String
	CustomDomain    optional.String
	ApiID           optional.String
	AllowList       optional.Interface
	MockResponse    optional.Interface
	ValidateRequest optional.Interface
	Authentication  optional.Interface
}

type OASAPIsApiListApiOASOpts

type OASAPIsApiListApiOASOpts struct {
	Mode optional.String
}

type OASAPIsApiListApisOASOpts

type OASAPIsApiListApisOASOpts struct {
	Mode optional.String
}

type OASAPIsApiListOASApiVersionsOpts

type OASAPIsApiListOASApiVersionsOpts struct {
	SearchText optional.String
	AccessType optional.String
}

type OASAPIsApiPatchApiOASOpts

type OASAPIsApiPatchApiOASOpts struct {
	Body            optional.Interface
	UpstreamURL     optional.String
	ListenPath      optional.String
	CustomDomain    optional.String
	ValidateRequest optional.Interface
	AllowList       optional.Interface
	MockResponse    optional.Interface
	Authentication  optional.Interface
}

type OASAPIsApiService

type OASAPIsApiService service

func (*OASAPIsApiService) CreateApiOAS

func (a *OASAPIsApiService) CreateApiOAS(ctx context.Context, localVarOptionals *OASAPIsApiCreateApiOASOpts) (ApiModifyKeySuccess, *http.Response, error)

func (*OASAPIsApiService) DeleteOASApi

func (a *OASAPIsApiService) DeleteOASApi(ctx context.Context, apiID string) (ApiStatusMessage, *http.Response, error)

OASAPIsApiService 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.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param apiID The API ID

@return ApiStatusMessage

func (*OASAPIsApiService) DownloadApiOASPublic

func (a *OASAPIsApiService) DownloadApiOASPublic(ctx context.Context, apiID string, localVarOptionals *OASAPIsApiDownloadApiOASPublicOpts) (OasSchemaResponse, *http.Response, error)

func (*OASAPIsApiService) DownloadApisOASPublic

func (a *OASAPIsApiService) DownloadApisOASPublic(ctx context.Context, localVarOptionals *OASAPIsApiDownloadApisOASPublicOpts) ([]OasSchemaResponse, *http.Response, error)

func (*OASAPIsApiService) ImportOAS

func (*OASAPIsApiService) ListApiOAS

func (a *OASAPIsApiService) ListApiOAS(ctx context.Context, apiID string, localVarOptionals *OASAPIsApiListApiOASOpts) (OasSchemaResponse, *http.Response, error)

func (*OASAPIsApiService) ListApisOAS

func (a *OASAPIsApiService) ListApisOAS(ctx context.Context, localVarOptionals *OASAPIsApiListApisOASOpts) ([]OasSchemaResponse, *http.Response, error)

func (*OASAPIsApiService) ListOASApiVersions

func (a *OASAPIsApiService) ListOASApiVersions(ctx context.Context, apiID string, localVarOptionals *OASAPIsApiListOASApiVersionsOpts) (InlineResponse200, *http.Response, error)

func (*OASAPIsApiService) PatchApiOAS

func (a *OASAPIsApiService) PatchApiOAS(ctx context.Context, apiID string, localVarOptionals *OASAPIsApiPatchApiOASOpts) (ApiModifyKeySuccess, *http.Response, error)

func (*OASAPIsApiService) UpdateApiOAS

func (a *OASAPIsApiService) UpdateApiOAS(ctx context.Context, apiID string, localVarOptionals *OASAPIsApiUpdateApiOASOpts) (ApiModifyKeySuccess, *http.Response, error)

type OASAPIsApiUpdateApiOASOpts

type OASAPIsApiUpdateApiOASOpts struct {
	Body optional.Interface
}

type OAuthApiCreateOAuthClientOpts

type OAuthApiCreateOAuthClientOpts struct {
	Body optional.Interface
}

type OAuthApiService

type OAuthApiService service

func (*OAuthApiService) AuthorizeClient

func (a *OAuthApiService) AuthorizeClient(ctx context.Context, responseType string, clientId string, redirectUri string, keyRules string) (interface{}, *http.Response, error)

OAuthApiService Authorize client 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.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param responseType
  • @param clientId
  • @param redirectUri
  • @param keyRules

@return interface{}

func (*OAuthApiService) CreateOAuthClient

func (a *OAuthApiService) CreateOAuthClient(ctx context.Context, localVarOptionals *OAuthApiCreateOAuthClientOpts) (NewClientRequest, *http.Response, error)

func (*OAuthApiService) DeleteOAuthClient

func (a *OAuthApiService) DeleteOAuthClient(ctx context.Context, apiID string, keyName string) (ApiModifyKeySuccess, *http.Response, error)

OAuthApiService Delete OAuth client Please note that tokens issued with the client ID will still be valid until they expire.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param apiID The API ID
  • @param keyName The Client ID

@return ApiModifyKeySuccess

func (*OAuthApiService) GetOAuthClient

func (a *OAuthApiService) GetOAuthClient(ctx context.Context, apiID string, keyName string) (NewClientRequest, *http.Response, error)

OAuthApiService Get OAuth client

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param apiID The API ID
  • @param keyName The Client ID

@return NewClientRequest

func (*OAuthApiService) GetOAuthClientTokens

func (a *OAuthApiService) GetOAuthClientTokens(ctx context.Context, apiID string, keyName string) ([]string, *http.Response, error)

OAuthApiService List tokens 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. &lt;br/&gt; &lt;br/&gt; You can control how long you want to store expired tokens in this list using &#x60;oauth_token_expired_retain_period&#x60; gateway option, which specifies retain period for expired tokens stored in Redis. By default expired token not get removed. See &lt;a href&#x3D;\&quot;https://tyk.io/docs/configure/tyk-gateway-configuration-options/#a-name-oauth-token-expired-retain-period-a-oauth-token-expired-retain-period\&quot; target&#x3D;\&quot;_blank\&quot;&gt;here&lt;/a&gt; for more details.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param apiID The API ID
  • @param keyName The Client ID

@return []string

func (*OAuthApiService) InvalidateOAuthRefresh

func (a *OAuthApiService) InvalidateOAuthRefresh(ctx context.Context, apiId string, keyName string) (ApiModifyKeySuccess, *http.Response, error)

OAuthApiService Invalidate OAuth refresh token It is possible to invalidate refresh tokens in order to manage OAuth client access more robustly.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param apiId The API id
  • @param keyName Refresh token

@return ApiModifyKeySuccess

func (*OAuthApiService) ListOAuthClients

func (a *OAuthApiService) ListOAuthClients(ctx context.Context, apiID string) ([]NewClientRequest, *http.Response, error)

OAuthApiService List oAuth clients OAuth Clients are organised by API ID, and therefore are queried as such.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param apiID The API ID

@return []NewClientRequest

func (*OAuthApiService) RevokeAllTokens

func (a *OAuthApiService) RevokeAllTokens(ctx context.Context, clientId string, clientSecret string) (*http.Response, error)

OAuthApiService revoke all client&#x27;s tokens revoke all the tokens for a given oauth client

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param clientId
  • @param clientSecret

func (*OAuthApiService) RevokeSingleToken

func (a *OAuthApiService) RevokeSingleToken(ctx context.Context, token string, clientId string, tokenTypeHint string) (*http.Response, error)

OAuthApiService revoke token revoke a single token

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param token
  • @param clientId
  • @param tokenTypeHint

func (*OAuthApiService) UpdateoAuthClient

func (a *OAuthApiService) UpdateoAuthClient(ctx context.Context, apiID string) ([]NewClientRequest, *http.Response, error)

OAuthApiService Update OAuth metadata and Policy ID Allows you to update the metadata and Policy ID for an OAuth client.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param apiID The API ID

@return []NewClientRequest

type OAuthClientToken

type OAuthClientToken struct {
	Code    string `json:"code,omitempty"`
	Expires int64  `json:"expires,omitempty"`
}

type OasSchemaResponse

type OasSchemaResponse struct {
	Status  string `json:"status,omitempty"`
	Message string `json:"message,omitempty"`
	// <OAS schema definition>
	Schema string `json:"schema,omitempty"`
}

OAS schema endpoint response

type OauthAuthorizeclientBody

type OauthAuthorizeclientBody struct {
	// 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.
	ResponseType string `json:"response_type,omitempty"`
	// Should be provided by requesting client as part of authorisation request. The Client ID that is making the request.
	ClientId string `json:"client_id,omitempty"`
	// Should be provided by requesting client as part of authorisation request. Must match with the record stored with Tyk.
	RedirectUri string `json:"redirect_uri,omitempty"`
	// 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.
	KeyRules string `json:"key_rules,omitempty"`
}

type OauthRevokeAllBody

type OauthRevokeAllBody struct {
	// id of oauth client
	ClientId string `json:"client_id,omitempty"`
	// OAuth client secret to ensure that its a valid operation
	ClientSecret string `json:"client_secret,omitempty"`
}

type OauthRevokeBody

type OauthRevokeBody struct {
	// token to be revoked
	Token string `json:"token,omitempty"`
	// id of oauth client
	ClientId string `json:"client_id,omitempty"`
	// type of token to be revoked, if sent then the accepted values are access_token and refresh_token. String value and optional, of not provided then it will attempt to remove access and refresh tokens that matchs
	TokenTypeHint string `json:"token_type_hint,omitempty"`
}

type Object

type Object struct{}

type OidProviderConfig

type OidProviderConfig struct {
	ClientIds map[string]string `json:"client_ids,omitempty"`
	Issuer    string            `json:"issuer,omitempty"`
}

type OpenIdOptions

type OpenIdOptions struct {
	Providers         []OidProviderConfig `json:"providers,omitempty"`
	SegregateByClient bool                `json:"segregate_by_client,omitempty"`
}

type OrganisationQuotasApiAddOrgKeyOpts

type OrganisationQuotasApiAddOrgKeyOpts struct {
	Body optional.Interface
}

type OrganisationQuotasApiService

type OrganisationQuotasApiService service

func (*OrganisationQuotasApiService) AddOrgKey

func (*OrganisationQuotasApiService) DeleteOrgKey

OrganisationQuotasApiService Delete Organisation Key Deleting a key will remove all limits from organisation. It does not affects regualar keys created within organisation.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param keyID The Key ID

@return ApiStatusMessage

func (*OrganisationQuotasApiService) GetOrgKey

OrganisationQuotasApiService Get an Organisation Key Get session info about specified orgnanisation key. Should return up to date rate limit and quota usage numbers.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param keyID The Key ID

@return SessionState

func (*OrganisationQuotasApiService) ListOrgKeys

OrganisationQuotasApiService List Organisation Keys 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&#x27;t want to have organisation level rate limiting, set &#x27;rate&#x27; or &#x27;per&#x27; to zero, or don&#x27;t add them to your request.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return InlineResponse2002

func (*OrganisationQuotasApiService) UpdateOrgKey

type OrganisationQuotasApiUpdateOrgKeyOpts

type OrganisationQuotasApiUpdateOrgKeyOpts struct {
	Body       optional.Interface
	ResetQuota optional.String
}

type Paths

type Paths struct {
}

type PkixAttributeTypeAndValue

type PkixAttributeTypeAndValue struct {
	Type_ []int32      `json:"Type,omitempty"`
	Value *interface{} `json:"Value,omitempty"`
}

AttributeTypeAndValue mirrors the ASN.1 structure of the same name in RFC 5280, Section 4.1.2.4.

type PkixAttributeTypeAndValueSet

type PkixAttributeTypeAndValueSet struct {
	Type_ []int32                       `json:"Type,omitempty"`
	Value [][]PkixAttributeTypeAndValue `json:"Value,omitempty"`
}

AttributeTypeAndValueSET represents a set of ASN.1 sequences of AttributeTypeAndValue sequences from RFC 2986 (PKCS

type PkixName

type PkixName struct {
	Country            []string                       `json:"Country,omitempty"`
	Organization       []string                       `json:"Organization,omitempty"`
	OrganizationalUnit []string                       `json:"OrganizationalUnit,omitempty"`
	Locality           []string                       `json:"Locality,omitempty"`
	Province           []string                       `json:"Province,omitempty"`
	StreetAddress      []string                       `json:"StreetAddress,omitempty"`
	PostalCode         []string                       `json:"PostalCode,omitempty"`
	SerialNumber       string                         `json:"SerialNumber,omitempty"`
	CommonName         string                         `json:"CommonName,omitempty"`
	Names              []PkixAttributeTypeAndValue    `json:"Names,omitempty"`
	ExtraNames         []PkixAttributeTypeAndValueSet `json:"ExtraNames,omitempty"`
}

Name represents an X.509 distinguished name

type PoliciesApiAddPolicyOpts

type PoliciesApiAddPolicyOpts struct {
	Body optional.Interface
}

type PoliciesApiService

type PoliciesApiService service

func (*PoliciesApiService) AddPolicy

func (*PoliciesApiService) DeletePolicy

PoliciesApiService Delete a Policy Delete a policy by ID in your Tyk instance.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param polID The policy ID

@return ApiModifyKeySuccess

func (*PoliciesApiService) GetPolicy

func (a *PoliciesApiService) GetPolicy(ctx context.Context, polID string) (Policy, *http.Response, error)

PoliciesApiService Get a Policy You can retrieve details of a single policy by ID in your Tyk instance. Returns an array policies.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
  • @param polID The policy ID

@return Policy

func (*PoliciesApiService) ListPolicies

func (a *PoliciesApiService) ListPolicies(ctx context.Context) ([]Policy, *http.Response, error)

PoliciesApiService List Policies You can retrieve all the policies in your Tyk instance. Returns an array policies.

  • @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().

@return []Policy

func (*PoliciesApiService) UpdatePolicy

func (a *PoliciesApiService) UpdatePolicy(ctx context.Context, polID string, localVarOptionals *PoliciesApiUpdatePolicyOpts) (ApiModifyKeySuccess, *http.Response, error)

type PoliciesApiUpdatePolicyOpts

type PoliciesApiUpdatePolicyOpts struct {
	Body optional.Interface
}

type Policy

type Policy struct {
	InternalId                    string                      `json:"_id,omitempty"`
	Id                            string                      `json:"id,omitempty"`
	Name                          string                      `json:"name,omitempty"`
	OrgId                         string                      `json:"org_id,omitempty"`
	Rate                          float64                     `json:"rate,omitempty"`
	Per                           float64                     `json:"per,omitempty"`
	QuotaMax                      int64                       `json:"quota_max,omitempty"`
	QuotaRenewalRate              int64                       `json:"quota_renewal_rate,omitempty"`
	ThrottleInterval              float64                     `json:"throttle_interval,omitempty"`
	ThrottleRetryLimit            float64                     `json:"throttle_retry_limit,omitempty"`
	MaxQueryDepth                 float64                     `json:"max_query_depth,omitempty"`
	AccessRights                  map[string]AccessDefinition `json:"access_rights,omitempty"`
	HmacEnabled                   bool                        `json:"hmac_enabled,omitempty"`
	EnableHttpSignatureValidation bool                        `json:"enable_http_signature_validation,omitempty"`
	Active                        bool                        `json:"active,omitempty"`
	IsInactive                    bool                        `json:"is_inactive,omitempty"`
	Tags                          []string                    `json:"tags,omitempty"`
	KeyExpiresIn                  float64                     `json:"key_expires_in,omitempty"`
	Partitions                    *PolicyPartitions           `json:"partitions,omitempty"`
	LastUpdated                   string                      `json:"last_updated,omitempty"`
	Smoothing                     *RateLimitSmoothing         `json:"smoothing,omitempty"`
	MetaData                      *interface{}                `json:"meta_data,omitempty"`
	GraphqlAccessRights           *GraphAccessDefinition      `json:"graphql_access_rights,omitempty"`
}

type PolicyPartitions

type PolicyPartitions struct {
	Quota      bool `json:"quota,omitempty"`
	RateLimit  bool `json:"rate_limit,omitempty"`
	Complexity bool `json:"complexity,omitempty"`
	Acl        bool `json:"acl,omitempty"`
	PerApi     bool `json:"per_api,omitempty"`
}

type RateLimitMeta

type RateLimitMeta struct {
	Disabled bool    `json:"disabled,omitempty"`
	Method   string  `json:"method,omitempty"`
	Path     string  `json:"path,omitempty"`
	Per      float64 `json:"per,omitempty"`
	Rate     float64 `json:"rate,omitempty"`
}

type RateLimitSmoothing

type RateLimitSmoothing struct {
	// Delay is a hold-off between smoothing events and controls how frequently the current allowance will step up or down (in seconds).
	Delay int64 `json:"delay,omitempty"`
	// Enabled indicates if rate limit smoothing is active.
	Enabled bool `json:"enabled,omitempty"`
	// Step is the increment by which the current allowance will be increased or decreased each time a smoothing event is emitted.
	Step int64 `json:"step,omitempty"`
	// Threshold is the initial rate limit beyond which smoothing will be applied. It is a count of requests during the `per` interval and should be less than the maximum configured `rate`.
	Threshold int64 `json:"threshold,omitempty"`
	// Trigger is a fraction (typically in the range 0.1-1.0) of the step at which point a smoothing event will be emitted as the request rate approaches the current allowance.
	Trigger float64 `json:"trigger,omitempty"`
}

Rate Limit Smoothing is a mechanism to dynamically adjust the request rate limits based on the current traffic patterns. It helps in managing request spikes by gradually increasing or decreasing the rate limit instead of making abrupt changes or blocking requests excessively. Once the rate limit smoothing triggers an allowance change, one of the following events is emitted: - `RateLimitSmoothingUp` when the allowance increases - `RateLimitSmoothingDown` when the allowance decreases Events are emitted based on the configuration: - `enabled` (boolean) to enable or disable rate limit smoothing - `threshold` after which to apply smoothing (minimum rate for window) - `trigger` configures at which fraction of a step a smoothing event is emitted - `step` is the value by which the rate allowance will get adjusted - `delay` is a hold-off in seconds providing a minimum period between rate allowance adjustments To determine if the request rate is growing and needs to be smoothed, the `step * trigger` value is subtracted from the request allowance and, if the request rate goes above that, then a RateLimitSmoothingUp event is emitted and the rate allowance is increased by `step`. Once the request allowance has been increased above the `threshold`, Tyk will start to check for decreasing request rate. When the request rate drops `step * (1 + trigger)` below the request allowance, a `RateLimitSmoothingDown` event is emitted and the rate allowance is decreased by `step`. After the request allowance has been adjusted (up or down), the request rate will be checked again over the next `delay` seconds and, if required, further adjustment made to the rate allowance after the hold-off. For any allowance, events are emitted based on the following calculations: - When the request rate rises above `allowance - (step * trigger)`, a RateLimitSmoothingUp event is emitted and allowance increases by `step`. - When the request rate falls below `allowance - (step + step * trigger)`, a RateLimitSmoothingDown event is emitted and allowance decreases by `step`. Example: Threshold: 400, Request allowance: 600, Current rate: 500, Step: 100, Trigger: 0.5. To trigger a RateLimitSmoothingUp event, the request rate must exceed: - Calculation: Allowance - (Step * Trigger). - Example: 600 - (100 * 0.5) = `550`. Exceeding a request rate of `550` will increase the allowance to 700 (Allowance + Step). To trigger a RateLimitSmoothingDown event, the request rate must fall below: - Calculation: Allowance - (Step + (Step * Trigger)). - Example: 600 - (100 + (100 * 0.5)) = 450. As the request rate falls below 450, that will decrease the allowance to 500 (Allowance - Step). The request allowance will be smoothed between `threshold`, and the defined `rate` limit (maximum). The request allowance will be updated internally every `delay` seconds.

type Regexp

type Regexp struct {
	FromCache bool `json:"FromCache,omitempty"`
}

Regexp is a wrapper around regexp.Regexp but with caching

type RequestSizeMeta

type RequestSizeMeta struct {
	Method    string `json:"method,omitempty"`
	Path      string `json:"path,omitempty"`
	SizeLimit int64  `json:"size_limit,omitempty"`
}

type ResponseProcessor

type ResponseProcessor struct {
	Name    string       `json:"name,omitempty"`
	Options *interface{} `json:"options,omitempty"`
}

type RoutingTrigger

type RoutingTrigger struct {
	On        string                 `json:"on,omitempty"`
	Options   *RoutingTriggerOptions `json:"options,omitempty"`
	RewriteTo string                 `json:"rewrite_to,omitempty"`
}

type RoutingTriggerOptions

type RoutingTriggerOptions struct {
	HeaderMatches         map[string]StringRegexMap `json:"header_matches,omitempty"`
	PathPartMatches       map[string]StringRegexMap `json:"path_part_matches,omitempty"`
	PayloadMatches        *StringRegexMap           `json:"payload_matches,omitempty"`
	QueryValMatches       map[string]StringRegexMap `json:"query_val_matches,omitempty"`
	RequestContextMatches map[string]StringRegexMap `json:"request_context_matches,omitempty"`
	SessionMetaMatches    map[string]StringRegexMap `json:"session_meta_matches,omitempty"`
}

type Schema

type Schema struct {
	Openapi      string                 `json:"openapi"`
	Info         *Info                  `json:"info"`
	ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"`
	Servers      []Server               `json:"servers,omitempty"`
	Security     []map[string][]string  `json:"security,omitempty"`
	Tags         []Tag                  `json:"tags,omitempty"`
	Paths        *Paths                 `json:"paths"`
	Components   *Components            `json:"components,omitempty"`
}

The description of OpenAPI v3.0.x documents, as defined by https://spec.openapis.org/oas/v3.0.3

type SchemaApiGetSchemaOpts

type SchemaApiGetSchemaOpts struct {
	OasVersion optional.String
}

type SchemaApiService

type SchemaApiService service

func (*SchemaApiService) GetSchema

func (a *SchemaApiService) GetSchema(ctx context.Context, localVarOptionals *SchemaApiGetSchemaOpts) (OasSchemaResponse, *http.Response, error)

type Server

type Server struct {
	Url         string                    `json:"url"`
	Description string                    `json:"description,omitempty"`
	Variables   map[string]ServerVariable `json:"variables,omitempty"`
}

type ServerVariable

type ServerVariable struct {
	Enum        []string `json:"enum,omitempty"`
	Default_    string   `json:"default"`
	Description string   `json:"description,omitempty"`
}

type ServiceDiscoveryConfiguration

type ServiceDiscoveryConfiguration struct {
	CacheTimeout        int64  `json:"cache_timeout,omitempty"`
	DataPath            string `json:"data_path,omitempty"`
	EndpointReturnsList bool   `json:"endpoint_returns_list,omitempty"`
	ParentDataPath      string `json:"parent_data_path,omitempty"`
	PortDataPath        string `json:"port_data_path,omitempty"`
	QueryEndpoint       string `json:"query_endpoint,omitempty"`
	TargetPath          string `json:"target_path,omitempty"`
	UseDiscoveryService bool   `json:"use_discovery_service,omitempty"`
	UseNestedQuery      bool   `json:"use_nested_query,omitempty"`
	UseTargetList       bool   `json:"use_target_list,omitempty"`
}

type SessionProviderMeta

type SessionProviderMeta struct {
	Meta          map[string]interface{} `json:"meta,omitempty"`
	Name          string                 `json:"name,omitempty"`
	StorageEngine string                 `json:"storage_engine,omitempty"`
}

type SessionState

type SessionState struct {
	Tags                  []string                    `json:"tags,omitempty"`
	AccessRights          map[string]AccessDefinition `json:"access_rights,omitempty"`
	Alias                 string                      `json:"alias,omitempty"`
	Allowance             float64                     `json:"allowance,omitempty"`
	ApplyPolicies         []string                    `json:"apply_policies,omitempty"`
	ApplyPolicyId         string                      `json:"apply_policy_id,omitempty"`
	BasicAuthData         *SessionStateBasicAuthData  `json:"basic_auth_data,omitempty"`
	Certificate           string                      `json:"certificate,omitempty"`
	DataExpires           int64                       `json:"data_expires,omitempty"`
	EnableDetailRecording bool                        `json:"enable_detail_recording,omitempty"`
	Expires               int64                       `json:"expires,omitempty"`
	HmacEnabled           bool                        `json:"hmac_enabled,omitempty"`
	HmacString            string                      `json:"hmac_string,omitempty"`
	IdExtractorDeadline   int64                       `json:"id_extractor_deadline,omitempty"`
	IsInactive            bool                        `json:"is_inactive,omitempty"`
	JwtData               *SessionStateJwtData        `json:"jwt_data,omitempty"`
	LastCheck             int64                       `json:"last_check,omitempty"`
	LastUpdated           string                      `json:"last_updated,omitempty"`
	MetaData              map[string]interface{}      `json:"meta_data,omitempty"`
	Monitor               *SessionStateMonitor        `json:"monitor,omitempty"`
	OauthClientId         string                      `json:"oauth_client_id,omitempty"`
	OauthKeys             map[string]string           `json:"oauth_keys,omitempty"`
	OrgId                 string                      `json:"org_id,omitempty"`
	Per                   float64                     `json:"per,omitempty"`
	QuotaMax              int64                       `json:"quota_max,omitempty"`
	QuotaRemaining        int64                       `json:"quota_remaining,omitempty"`
	QuotaRenewalRate      int64                       `json:"quota_renewal_rate,omitempty"`
	QuotaRenews           int64                       `json:"quota_renews,omitempty"`
	Rate                  float64                     `json:"rate,omitempty"`
	SessionLifetime       int64                       `json:"session_lifetime,omitempty"`
	Smoothing             *RateLimitSmoothing         `json:"smoothing,omitempty"`
	ThrottleInterval      float64                     `json:"throttle_interval,omitempty"`
	ThrottleRetryLimit    int64                       `json:"throttle_retry_limit,omitempty"`
}

There's a data structure that's based on this and it's used for Protocol Buffer support, make sure to update \"coprocess/proto/coprocess_session_state.proto\" and generate the bindings using: cd coprocess/proto && ./update_bindings.sh

type SessionStateBasicAuthData

type SessionStateBasicAuthData struct {
	HashType string `json:"hash_type,omitempty"`
	Password string `json:"password,omitempty"`
}

type SessionStateJwtData

type SessionStateJwtData struct {
	Secret string `json:"secret,omitempty"`
}

type SessionStateMonitor

type SessionStateMonitor struct {
	TriggerLimits []float64 `json:"trigger_limits,omitempty"`
}

type SignatureConfig

type SignatureConfig struct {
	Algorithm        string `json:"algorithm,omitempty"`
	AllowedClockSkew int64  `json:"allowed_clock_skew,omitempty"`
	ErrorCode        int64  `json:"error_code,omitempty"`
	ErrorMessage     string `json:"error_message,omitempty"`
	Header           string `json:"header,omitempty"`
	Secret           string `json:"secret,omitempty"`
}

type StringRegexMap

type StringRegexMap struct {
	MatchRx string `json:"match_rx,omitempty"`
	Reverse bool   `json:"reverse,omitempty"`
}

type Tag

type Tag struct {
	Name         string                 `json:"name"`
	Description  string                 `json:"description,omitempty"`
	ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"`
}

type TemplateData

type TemplateData struct {
	EnableSession  bool   `json:"enable_session,omitempty"`
	InputType      string `json:"input_type,omitempty"`
	TemplateMode   string `json:"template_mode,omitempty"`
	TemplateSource string `json:"template_source,omitempty"`
}

type TemplateMeta

type TemplateMeta struct {
	Method       string        `json:"method,omitempty"`
	Path         string        `json:"path,omitempty"`
	TemplateData *TemplateData `json:"template_data,omitempty"`
}

type TrackEndpointMeta

type TrackEndpointMeta struct {
	Method string `json:"method,omitempty"`
	Path   string `json:"path,omitempty"`
}

type TransformJqMeta

type TransformJqMeta struct {
	Filter string `json:"filter,omitempty"`
	Method string `json:"method,omitempty"`
	Path   string `json:"path,omitempty"`
}

type UrlRewriteMeta

type UrlRewriteMeta struct {
	MatchRegexp  *Regexp          `json:"MatchRegexp,omitempty"`
	MatchPattern string           `json:"match_pattern,omitempty"`
	Method       string           `json:"method,omitempty"`
	Path         string           `json:"path,omitempty"`
	RewriteTo    string           `json:"rewrite_to,omitempty"`
	Triggers     []RoutingTrigger `json:"triggers,omitempty"`
}

type ValidatePathMeta

type ValidatePathMeta struct {
	// Allows override of default 422 Unprocessible Entity response code for validation errors.
	ErrorResponseCode int64                  `json:"error_response_code,omitempty"`
	Method            string                 `json:"method,omitempty"`
	Path              string                 `json:"path,omitempty"`
	Schema            map[string]interface{} `json:"schema,omitempty"`
	SchemaB64         string                 `json:"schema_b64,omitempty"`
}

type VersionInfo

type VersionInfo struct {
	Paths               *VersionInfoPaths `json:"paths,omitempty"`
	Expires             string            `json:"expires,omitempty"`
	ExtendedPaths       *ExtendedPathsSet `json:"extended_paths,omitempty"`
	GlobalHeaders       map[string]string `json:"global_headers,omitempty"`
	GlobalHeadersRemove []string          `json:"global_headers_remove,omitempty"`
	GlobalSizeLimit     int64             `json:"global_size_limit,omitempty"`
	Name                string            `json:"name,omitempty"`
	OverrideTarget      string            `json:"override_target,omitempty"`
	UseExtendedPaths    bool              `json:"use_extended_paths,omitempty"`
}

type VersionInfoPaths

type VersionInfoPaths struct {
	BlackList []string `json:"black_list,omitempty"`
	Ignored   []string `json:"ignored,omitempty"`
	WhiteList []string `json:"white_list,omitempty"`
}

type VirtualMeta

type VirtualMeta struct {
	FunctionSourceType   string `json:"function_source_type,omitempty"`
	FunctionSourceUri    string `json:"function_source_uri,omitempty"`
	Method               string `json:"method,omitempty"`
	Path                 string `json:"path,omitempty"`
	ProxyOnError         bool   `json:"proxy_on_error,omitempty"`
	ResponseFunctionName string `json:"response_function_name,omitempty"`
	UseSession           bool   `json:"use_session,omitempty"`
}

Source Files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL