@lap v0.3
# Machine-readable API spec. Each @endpoint block is one API call.
@api Otoroshi Admin API
@base http://otoroshi-api.oto.tools/
@version 1.5.0-dev
@auth Bearer basic
@endpoints 102
@hint download_for_search
@toc new(3), lines(2), api(96), health(1)

@group new
@endpoint GET /new/apikey
@returns(200) {clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool, throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@errors {400, 401, 404}

@endpoint GET /new/service
@returns(200) {id: str(uuid), groups: [str], name: str, env: str, domain: str, subdomain: str, targets: [map], root: str, matchingRoot: str, localHost: str, localScheme: str, redirectToLocal: bool, enabled: bool, userFacing: bool, privateApp: bool, forceHttps: bool, maintenanceMode: bool, buildMode: bool, enforceSecureCommunication: bool, sendOtoroshiHeadersBack: bool, xForwardedHeaders: bool, overrideHost: bool, secComExcludedPatterns: [str], publicPatterns: [str], privatePatterns: [str], ipFiltering: map{whitelist: [str(ipv4)], blacklist: [str(ipv4)]}, api: map{exposeApi: bool, openApiDescriptorUrl: str(uri)}, healthCheck: map{enabled: bool, url: str(uri)}, clientConfig: map{useCircuitBreaker: bool, retries: int(int32), maxErrors: int(int32), retryInitialDelay: int(int32), backoffFactor: int(int32), callTimeout: int(int32), globalTimeout: int(int32), sampleInterval: int(int32)}, Canary: map{enabled: bool, traffic: int(int32), targets: [map], root: str}, statsdConfig: map{host: str, port: int(int32), datadog: bool}, chaosConfig: map{enabled: bool, largeRequestFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, largeResponseFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, latencyInjectionFaultConfig: map{ratio: int(double), from: int(int32), to: int(int32)}, badResponsesFaultConfig: map{ratio: int(double), responses: [map]}}, jwtVerifier: any, secComSettings: any, metadata: map, matchingHeaders: map, additionalHeaders: map, authConfigRef: str, transformerRef: str, clientValidatorRef: str, cors: map{enabled: bool, allowOrigin: str, exposeHeaders: [str], allowHeaders: [str], allowMethods: [str], excludedPatterns: [str], maxAge: int(int32), allowCredentials: bool}, redirection: map{enabled: bool, to: str, code: int(int32)}, gzip: map{enabled: bool, excludedPatterns: [str], whiteList: [str], blackList: [str], bufferSize: int(int64), chunkedThreshold: int(int64), compressionLevel: int(int32)}, headersVerification: map}
@errors {400, 401, 404}

@endpoint GET /new/group
@returns(200) {id: str, name: str, description: str}
@errors {400, 401, 404}

@endgroup

@group lines
@endpoint GET /lines
@returns(200)
@errors {400, 401, 404}

@endpoint GET /lines/{line}/services
@required {line: str}
@returns(200)
@errors {400, 401, 404}

@endgroup

@group api
@endpoint GET /api/services/{serviceId}/apikeys/{clientId}/quotas
@required {serviceId: str, clientId: str}
@returns(200) {authorizedCallsPerSec: int(int64), currentCallsPerSec: int(int64), remainingCallsPerSec: int(int64), authorizedCallsPerDay: int(int64), currentCallsPerDay: int(int64), remainingCallsPerDay: int(int64), authorizedCallsPerMonth: int(int64), currentCallsPerMonth: int(int64), remainingCallsPerMonth: int(int64)}
@errors {400, 401, 404}

@endpoint DELETE /api/services/{serviceId}/apikeys/{clientId}/quotas
@required {serviceId: str, clientId: str}
@returns(200) {authorizedCallsPerSec: int(int64), currentCallsPerSec: int(int64), remainingCallsPerSec: int(int64), authorizedCallsPerDay: int(int64), currentCallsPerDay: int(int64), remainingCallsPerDay: int(int64), authorizedCallsPerMonth: int(int64), currentCallsPerMonth: int(int64), remainingCallsPerMonth: int(int64)}
@errors {400, 401, 404}

@endpoint GET /api/services/{serviceId}/apikeys/{clientId}/group
@required {serviceId: str, clientId: str}
@returns(200) {id: str, name: str, description: str}
@errors {400, 401, 404}

@endpoint GET /api/services/{serviceId}/apikeys/{clientId}
@required {serviceId: str, clientId: str}
@returns(200) {clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool, throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@errors {400, 401, 404}

@endpoint PUT /api/services/{serviceId}/apikeys/{clientId}
@required {serviceId: str, clientId: str, clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool}
@optional {throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@returns(200) {clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool, throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@errors {400, 401, 404}

@endpoint PATCH /api/services/{serviceId}/apikeys/{clientId}
@required {serviceId: str, clientId: str}
@returns(200) {clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool, throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@errors {400, 401, 404}

@endpoint DELETE /api/services/{serviceId}/apikeys/{clientId}
@required {serviceId: str, clientId: str}
@returns(200) {deleted: bool}
@errors {400, 401, 404}

@endpoint GET /api/services/{serviceId}/apikeys
@required {serviceId: str}
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/services/{serviceId}/apikeys
@required {serviceId: str, clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool}
@optional {throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@returns(200) {clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool, throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@errors {400, 401, 404}

@endpoint GET /api/groups/{groupId}/apikeys/{clientId}/quotas
@required {groupId: str, clientId: str}
@returns(200) {authorizedCallsPerSec: int(int64), currentCallsPerSec: int(int64), remainingCallsPerSec: int(int64), authorizedCallsPerDay: int(int64), currentCallsPerDay: int(int64), remainingCallsPerDay: int(int64), authorizedCallsPerMonth: int(int64), currentCallsPerMonth: int(int64), remainingCallsPerMonth: int(int64)}
@errors {400, 401, 404}

@endpoint DELETE /api/groups/{groupId}/apikeys/{clientId}/quotas
@required {groupId: str, clientId: str}
@returns(200) {authorizedCallsPerSec: int(int64), currentCallsPerSec: int(int64), remainingCallsPerSec: int(int64), authorizedCallsPerDay: int(int64), currentCallsPerDay: int(int64), remainingCallsPerDay: int(int64), authorizedCallsPerMonth: int(int64), currentCallsPerMonth: int(int64), remainingCallsPerMonth: int(int64)}
@errors {400, 401, 404}

@endpoint GET /api/groups/{groupId}/apikeys/{clientId}
@required {groupId: str, clientId: str}
@returns(200) {clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool, throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@errors {400, 401, 404}

@endpoint PUT /api/groups/{groupId}/apikeys/{clientId}
@required {groupId: str, clientId: str, clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool}
@optional {throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@returns(200) {clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool, throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@errors {400, 401, 404}

@endpoint PATCH /api/groups/{groupId}/apikeys/{clientId}
@required {groupId: str, clientId: str}
@returns(200) {clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool, throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@errors {400, 401, 404}

@endpoint DELETE /api/groups/{groupId}/apikeys/{clientId}
@required {groupId: str, clientId: str}
@returns(200) {deleted: bool}
@errors {400, 401, 404}

@endpoint GET /api/groups/{groupId}/apikeys
@required {groupId: str}
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/groups/{groupId}/apikeys
@required {groupId: str, clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool}
@optional {throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@returns(200) {clientId: str, clientSecret: str, clientName: str, authorizedEntities: [str], enabled: bool, throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}
@errors {400, 401, 404}

@endpoint GET /api/apikeys
@returns(200)
@errors {400, 401, 404}

@endpoint GET /api/services/{serviceId}/template
@required {serviceId: str}
@returns(200) {serviceId: str, template40x: str, template50x: str, templateBuild: str, templateMaintenance: str, messages: map}
@errors {400, 401, 404}

@endpoint PUT /api/services/{serviceId}/template
@required {serviceId: str, serviceId: str, template40x: str, template50x: str, templateBuild: str, templateMaintenance: str, messages: map}
@returns(200) {serviceId: str, template40x: str, template50x: str, templateBuild: str, templateMaintenance: str, messages: map}
@errors {400, 401, 404}

@endpoint POST /api/services/{serviceId}/template
@required {serviceId: str, serviceId: str, template40x: str, template50x: str, templateBuild: str, templateMaintenance: str, messages: map}
@returns(200) {serviceId: str, template40x: str, template50x: str, templateBuild: str, templateMaintenance: str, messages: map}
@errors {400, 401, 404}

@endpoint DELETE /api/services/{serviceId}/template
@required {serviceId: str}
@returns(200) {deleted: bool}
@errors {400, 401, 404}

@endpoint GET /api/services/{serviceId}/targets
@required {serviceId: str}
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/services/{serviceId}/targets
@required {serviceId: str, host: str(hostname), scheme: str}
@returns(200)
@errors {400, 401, 404}

@endpoint PATCH /api/services/{serviceId}/targets
@required {serviceId: str}
@returns(200)
@errors {400, 401, 404}

@endpoint DELETE /api/services/{serviceId}/targets
@required {serviceId: str}
@returns(200)
@errors {400, 401, 404}

@endpoint GET /api/services/{serviceId}
@required {serviceId: str}
@returns(200) {id: str(uuid), groups: [str], name: str, env: str, domain: str, subdomain: str, targets: [map], root: str, matchingRoot: str, localHost: str, localScheme: str, redirectToLocal: bool, enabled: bool, userFacing: bool, privateApp: bool, forceHttps: bool, maintenanceMode: bool, buildMode: bool, enforceSecureCommunication: bool, sendOtoroshiHeadersBack: bool, xForwardedHeaders: bool, overrideHost: bool, secComExcludedPatterns: [str], publicPatterns: [str], privatePatterns: [str], ipFiltering: map{whitelist: [str(ipv4)], blacklist: [str(ipv4)]}, api: map{exposeApi: bool, openApiDescriptorUrl: str(uri)}, healthCheck: map{enabled: bool, url: str(uri)}, clientConfig: map{useCircuitBreaker: bool, retries: int(int32), maxErrors: int(int32), retryInitialDelay: int(int32), backoffFactor: int(int32), callTimeout: int(int32), globalTimeout: int(int32), sampleInterval: int(int32)}, Canary: map{enabled: bool, traffic: int(int32), targets: [map], root: str}, statsdConfig: map{host: str, port: int(int32), datadog: bool}, chaosConfig: map{enabled: bool, largeRequestFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, largeResponseFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, latencyInjectionFaultConfig: map{ratio: int(double), from: int(int32), to: int(int32)}, badResponsesFaultConfig: map{ratio: int(double), responses: [map]}}, jwtVerifier: any, secComSettings: any, metadata: map, matchingHeaders: map, additionalHeaders: map, authConfigRef: str, transformerRef: str, clientValidatorRef: str, cors: map{enabled: bool, allowOrigin: str, exposeHeaders: [str], allowHeaders: [str], allowMethods: [str], excludedPatterns: [str], maxAge: int(int32), allowCredentials: bool}, redirection: map{enabled: bool, to: str, code: int(int32)}, gzip: map{enabled: bool, excludedPatterns: [str], whiteList: [str], blackList: [str], bufferSize: int(int64), chunkedThreshold: int(int64), compressionLevel: int(int32)}, headersVerification: map}
@errors {400, 401, 404}

@endpoint PUT /api/services/{serviceId}
@required {serviceId: str, id: str(uuid), groups: [str], name: str, env: str, domain: str, subdomain: str, targets: [map{host!: str(hostname), scheme!: str}], root: str, enabled: bool, privateApp: bool, forceHttps: bool, maintenanceMode: bool, buildMode: bool, enforceSecureCommunication: bool}
@optional {matchingRoot: str, localHost: str, localScheme: str, redirectToLocal: bool, userFacing: bool, sendOtoroshiHeadersBack: bool, xForwardedHeaders: bool, overrideHost: bool, secComExcludedPatterns: [str], publicPatterns: [str], privatePatterns: [str], ipFiltering: map{whitelist!: [str(ipv4)], blacklist!: [str(ipv4)]}, api: map{exposeApi!: bool, openApiDescriptorUrl: str(uri)}, healthCheck: map{enabled!: bool, url: str(uri)}, clientConfig: map{useCircuitBreaker!: bool, retries!: int(int32), maxErrors!: int(int32), retryInitialDelay!: int(int32), backoffFactor!: int(int32), callTimeout!: int(int32), globalTimeout!: int(int32), sampleInterval!: int(int32)}, Canary: map{enabled!: bool, traffic!: int(int32), targets!: [map], root!: str}, statsdConfig: map{host!: str, port!: int(int32), datadog!: bool}, chaosConfig: map{enabled!: bool, largeRequestFaultConfig: map, largeResponseFaultConfig: map, latencyInjectionFaultConfig: map, badResponsesFaultConfig: map}, jwtVerifier: any, secComSettings: any, metadata: map, matchingHeaders: map, additionalHeaders: map, authConfigRef: str, transformerRef: str, clientValidatorRef: str, cors: map{enabled!: bool, allowOrigin!: str, exposeHeaders!: [str], allowHeaders!: [str], allowMethods!: [str], excludedPatterns!: [str], maxAge!: int(int32), allowCredentials!: bool}, redirection: map{enabled!: bool, to!: str, code!: int(int32)}, gzip: map{enabled!: bool, excludedPatterns!: [str], whiteList!: [str], blackList!: [str], bufferSize!: int(int64), chunkedThreshold!: int(int64), compressionLevel!: int(int32)}, headersVerification: map}
@returns(200) {id: str(uuid), groups: [str], name: str, env: str, domain: str, subdomain: str, targets: [map], root: str, matchingRoot: str, localHost: str, localScheme: str, redirectToLocal: bool, enabled: bool, userFacing: bool, privateApp: bool, forceHttps: bool, maintenanceMode: bool, buildMode: bool, enforceSecureCommunication: bool, sendOtoroshiHeadersBack: bool, xForwardedHeaders: bool, overrideHost: bool, secComExcludedPatterns: [str], publicPatterns: [str], privatePatterns: [str], ipFiltering: map{whitelist: [str(ipv4)], blacklist: [str(ipv4)]}, api: map{exposeApi: bool, openApiDescriptorUrl: str(uri)}, healthCheck: map{enabled: bool, url: str(uri)}, clientConfig: map{useCircuitBreaker: bool, retries: int(int32), maxErrors: int(int32), retryInitialDelay: int(int32), backoffFactor: int(int32), callTimeout: int(int32), globalTimeout: int(int32), sampleInterval: int(int32)}, Canary: map{enabled: bool, traffic: int(int32), targets: [map], root: str}, statsdConfig: map{host: str, port: int(int32), datadog: bool}, chaosConfig: map{enabled: bool, largeRequestFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, largeResponseFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, latencyInjectionFaultConfig: map{ratio: int(double), from: int(int32), to: int(int32)}, badResponsesFaultConfig: map{ratio: int(double), responses: [map]}}, jwtVerifier: any, secComSettings: any, metadata: map, matchingHeaders: map, additionalHeaders: map, authConfigRef: str, transformerRef: str, clientValidatorRef: str, cors: map{enabled: bool, allowOrigin: str, exposeHeaders: [str], allowHeaders: [str], allowMethods: [str], excludedPatterns: [str], maxAge: int(int32), allowCredentials: bool}, redirection: map{enabled: bool, to: str, code: int(int32)}, gzip: map{enabled: bool, excludedPatterns: [str], whiteList: [str], blackList: [str], bufferSize: int(int64), chunkedThreshold: int(int64), compressionLevel: int(int32)}, headersVerification: map}
@errors {400, 401, 404}

@endpoint PATCH /api/services/{serviceId}
@required {serviceId: str}
@returns(200) {id: str(uuid), groups: [str], name: str, env: str, domain: str, subdomain: str, targets: [map], root: str, matchingRoot: str, localHost: str, localScheme: str, redirectToLocal: bool, enabled: bool, userFacing: bool, privateApp: bool, forceHttps: bool, maintenanceMode: bool, buildMode: bool, enforceSecureCommunication: bool, sendOtoroshiHeadersBack: bool, xForwardedHeaders: bool, overrideHost: bool, secComExcludedPatterns: [str], publicPatterns: [str], privatePatterns: [str], ipFiltering: map{whitelist: [str(ipv4)], blacklist: [str(ipv4)]}, api: map{exposeApi: bool, openApiDescriptorUrl: str(uri)}, healthCheck: map{enabled: bool, url: str(uri)}, clientConfig: map{useCircuitBreaker: bool, retries: int(int32), maxErrors: int(int32), retryInitialDelay: int(int32), backoffFactor: int(int32), callTimeout: int(int32), globalTimeout: int(int32), sampleInterval: int(int32)}, Canary: map{enabled: bool, traffic: int(int32), targets: [map], root: str}, statsdConfig: map{host: str, port: int(int32), datadog: bool}, chaosConfig: map{enabled: bool, largeRequestFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, largeResponseFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, latencyInjectionFaultConfig: map{ratio: int(double), from: int(int32), to: int(int32)}, badResponsesFaultConfig: map{ratio: int(double), responses: [map]}}, jwtVerifier: any, secComSettings: any, metadata: map, matchingHeaders: map, additionalHeaders: map, authConfigRef: str, transformerRef: str, clientValidatorRef: str, cors: map{enabled: bool, allowOrigin: str, exposeHeaders: [str], allowHeaders: [str], allowMethods: [str], excludedPatterns: [str], maxAge: int(int32), allowCredentials: bool}, redirection: map{enabled: bool, to: str, code: int(int32)}, gzip: map{enabled: bool, excludedPatterns: [str], whiteList: [str], blackList: [str], bufferSize: int(int64), chunkedThreshold: int(int64), compressionLevel: int(int32)}, headersVerification: map}
@errors {400, 401, 404}

@endpoint DELETE /api/services/{serviceId}
@required {serviceId: str}
@returns(200) {deleted: bool}
@errors {400, 401, 404}

@endpoint GET /api/services
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/services
@required {id: str(uuid), groups: [str], name: str, env: str, domain: str, subdomain: str, targets: [map{host!: str(hostname), scheme!: str}], root: str, enabled: bool, privateApp: bool, forceHttps: bool, maintenanceMode: bool, buildMode: bool, enforceSecureCommunication: bool}
@optional {matchingRoot: str, localHost: str, localScheme: str, redirectToLocal: bool, userFacing: bool, sendOtoroshiHeadersBack: bool, xForwardedHeaders: bool, overrideHost: bool, secComExcludedPatterns: [str], publicPatterns: [str], privatePatterns: [str], ipFiltering: map{whitelist!: [str(ipv4)], blacklist!: [str(ipv4)]}, api: map{exposeApi!: bool, openApiDescriptorUrl: str(uri)}, healthCheck: map{enabled!: bool, url: str(uri)}, clientConfig: map{useCircuitBreaker!: bool, retries!: int(int32), maxErrors!: int(int32), retryInitialDelay!: int(int32), backoffFactor!: int(int32), callTimeout!: int(int32), globalTimeout!: int(int32), sampleInterval!: int(int32)}, Canary: map{enabled!: bool, traffic!: int(int32), targets!: [map], root!: str}, statsdConfig: map{host!: str, port!: int(int32), datadog!: bool}, chaosConfig: map{enabled!: bool, largeRequestFaultConfig: map, largeResponseFaultConfig: map, latencyInjectionFaultConfig: map, badResponsesFaultConfig: map}, jwtVerifier: any, secComSettings: any, metadata: map, matchingHeaders: map, additionalHeaders: map, authConfigRef: str, transformerRef: str, clientValidatorRef: str, cors: map{enabled!: bool, allowOrigin!: str, exposeHeaders!: [str], allowHeaders!: [str], allowMethods!: [str], excludedPatterns!: [str], maxAge!: int(int32), allowCredentials!: bool}, redirection: map{enabled!: bool, to!: str, code!: int(int32)}, gzip: map{enabled!: bool, excludedPatterns!: [str], whiteList!: [str], blackList!: [str], bufferSize!: int(int64), chunkedThreshold!: int(int64), compressionLevel!: int(int32)}, headersVerification: map}
@returns(200) {id: str(uuid), groups: [str], name: str, env: str, domain: str, subdomain: str, targets: [map], root: str, matchingRoot: str, localHost: str, localScheme: str, redirectToLocal: bool, enabled: bool, userFacing: bool, privateApp: bool, forceHttps: bool, maintenanceMode: bool, buildMode: bool, enforceSecureCommunication: bool, sendOtoroshiHeadersBack: bool, xForwardedHeaders: bool, overrideHost: bool, secComExcludedPatterns: [str], publicPatterns: [str], privatePatterns: [str], ipFiltering: map{whitelist: [str(ipv4)], blacklist: [str(ipv4)]}, api: map{exposeApi: bool, openApiDescriptorUrl: str(uri)}, healthCheck: map{enabled: bool, url: str(uri)}, clientConfig: map{useCircuitBreaker: bool, retries: int(int32), maxErrors: int(int32), retryInitialDelay: int(int32), backoffFactor: int(int32), callTimeout: int(int32), globalTimeout: int(int32), sampleInterval: int(int32)}, Canary: map{enabled: bool, traffic: int(int32), targets: [map], root: str}, statsdConfig: map{host: str, port: int(int32), datadog: bool}, chaosConfig: map{enabled: bool, largeRequestFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, largeResponseFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, latencyInjectionFaultConfig: map{ratio: int(double), from: int(int32), to: int(int32)}, badResponsesFaultConfig: map{ratio: int(double), responses: [map]}}, jwtVerifier: any, secComSettings: any, metadata: map, matchingHeaders: map, additionalHeaders: map, authConfigRef: str, transformerRef: str, clientValidatorRef: str, cors: map{enabled: bool, allowOrigin: str, exposeHeaders: [str], allowHeaders: [str], allowMethods: [str], excludedPatterns: [str], maxAge: int(int32), allowCredentials: bool}, redirection: map{enabled: bool, to: str, code: int(int32)}, gzip: map{enabled: bool, excludedPatterns: [str], whiteList: [str], blackList: [str], bufferSize: int(int64), chunkedThreshold: int(int64), compressionLevel: int(int32)}, headersVerification: map}
@errors {400, 401, 404}

@endpoint GET /api/groups/{serviceGroupId}/services
@required {serviceGroupId: str}
@returns(200)
@errors {400, 401, 404}

@endpoint GET /api/groups/{serviceGroupId}
@required {serviceGroupId: str}
@returns(200) {id: str, name: str, description: str}
@errors {400, 401, 404}

@endpoint PUT /api/groups/{serviceGroupId}
@required {serviceGroupId: str, id: str, name: str}
@optional {description: str}
@returns(200) {id: str, name: str, description: str}
@errors {400, 401, 404}

@endpoint PATCH /api/groups/{serviceGroupId}
@required {serviceGroupId: str}
@returns(200) {id: str, name: str, description: str}
@errors {400, 401, 404}

@endpoint DELETE /api/groups/{serviceGroupId}
@required {serviceGroupId: str}
@returns(200) {deleted: bool}
@errors {400, 401, 404}

@endpoint GET /api/groups
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/groups
@required {id: str, name: str}
@optional {description: str}
@returns(200) {id: str, name: str, description: str}
@errors {400, 401, 404}

@endpoint GET /api/verifiers
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/verifiers
@required {id: str, name: str, desc: str, enabled: bool, strict: bool, source: any, algoSettings: any, strategy: any}
@returns(200) {id: str, name: str, desc: str, enabled: bool, strict: bool, source: any, algoSettings: any, strategy: any}
@errors {400, 401, 404}

@endpoint GET /api/verifiers/{verifierId}
@required {verifierId: str}
@returns(200) {id: str, name: str, desc: str, enabled: bool, strict: bool, source: any, algoSettings: any, strategy: any}
@errors {400, 401, 404}

@endpoint DELETE /api/verifiers/{verifierId}
@required {verifierId: str}
@returns(200) {deleted: bool}
@errors {400, 401, 404}

@endpoint PUT /api/verifiers/{verifierId}
@required {verifierId: str, id: str, name: str, desc: str, enabled: bool, strict: bool, source: any, algoSettings: any, strategy: any}
@returns(200) {id: str, name: str, desc: str, enabled: bool, strict: bool, source: any, algoSettings: any, strategy: any}
@errors {400, 401, 404}

@endpoint PATCH /api/verifiers/{verifierId}
@required {verifierId: str}
@returns(200) {id: str, name: str, desc: str, enabled: bool, strict: bool, source: any, algoSettings: any, strategy: any}
@errors {400, 401, 404}

@endpoint GET /api/auths
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/auths
@returns(200)
@errors {400, 401, 404}

@endpoint GET /api/auths/{id}
@required {id: str}
@returns(200)
@errors {400, 401, 404}

@endpoint DELETE /api/auths/{id}
@required {id: str}
@returns(200) {deleted: bool}
@errors {400, 401, 404}

@endpoint PUT /api/auths/{id}
@required {id: str}
@returns(200)
@errors {400, 401, 404}

@endpoint PATCH /api/auths/{id}
@required {id: str}
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/scripts/_compile
@required {id: str, name: str, desc: map, code: map}
@returns(200) {done: bool, error: map{line: str, column: str, file: map, rawMessage: map, message: map}}
@errors {400, 401, 404}

@endpoint GET /api/scripts/{scriptId}
@required {scriptId: str}
@returns(200) {id: str, name: str, desc: map, code: map}
@errors {400, 401, 404}

@endpoint PUT /api/scripts/{scriptId}
@required {scriptId: str, id: str, name: str, desc: map, code: map}
@returns(200) {id: str, name: str, desc: map, code: map}
@errors {400, 401, 404}

@endpoint PATCH /api/scripts/{scriptId}
@required {scriptId: str}
@returns(200) {id: str, name: str, desc: map, code: map}
@errors {400, 401, 404}

@endpoint DELETE /api/scripts/{scriptId}
@required {scriptId: str}
@returns(200) {deleted: bool}
@errors {400, 401, 404}

@endpoint GET /api/scripts
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/scripts
@required {id: str, name: str, desc: map, code: map}
@returns(200) {id: str, name: str, desc: map, code: map}
@errors {400, 401, 404}

@endpoint GET /api/data-exporter-configs/_template
@optional {type: str}
@returns(200) {enabled: str, typ: str, id: str, name: str, desc: str, metadata: map, location: map{tenant: str, teams: [map]}, bufferSize: int(int32), jsonWorkers: int(int32), sendWorkers: int(int32), groupSize: int(int32), groupDuration: int(int64), filtering: map{include: [map], exclude: [map]}, projection: map, config: any}
@errors {400, 401, 404}

@endpoint POST /api/data-exporter-configs/_bulk
@returns(200)
@errors {400, 401, 404}

@endpoint PUT /api/data-exporter-configs/_bulk
@returns(200)
@errors {400, 401, 404}

@endpoint PATCH /api/data-exporter-configs/_bulk
@returns(200)
@errors {400, 401, 404}

@endpoint DELETE /api/data-exporter-configs/_bulk
@returns(200)
@errors {400, 401, 404}

@endpoint GET /api/data-exporter-configs/{dataExporterConfigId}
@required {dataExporterConfigId: str}
@returns(200) {enabled: str, typ: str, id: str, name: str, desc: str, metadata: map, location: map{tenant: str, teams: [map]}, bufferSize: int(int32), jsonWorkers: int(int32), sendWorkers: int(int32), groupSize: int(int32), groupDuration: int(int64), filtering: map{include: [map], exclude: [map]}, projection: map, config: any}
@errors {400, 401, 404}

@endpoint PUT /api/data-exporter-configs/{dataExporterConfigId}
@required {dataExporterConfigId: str}
@optional {enabled: str, typ: str(kafka/pulsar/file/mailer/elastic/console/custom), id: str, name: str, desc: str, metadata: map, location: map{tenant!: str, teams!: [map]}, bufferSize: int(int32), jsonWorkers: int(int32), sendWorkers: int(int32), groupSize: int(int32), groupDuration: int(int64), filtering: map{include: [map], exclude: [map]}, projection: map, config: any}
@returns(200) {enabled: str, typ: str, id: str, name: str, desc: str, metadata: map, location: map{tenant: str, teams: [map]}, bufferSize: int(int32), jsonWorkers: int(int32), sendWorkers: int(int32), groupSize: int(int32), groupDuration: int(int64), filtering: map{include: [map], exclude: [map]}, projection: map, config: any}
@errors {400, 401, 404}

@endpoint PATCH /api/data-exporter-configs/{dataExporterConfigId}
@required {dataExporterConfigId: str}
@returns(200) {enabled: str, typ: str, id: str, name: str, desc: str, metadata: map, location: map{tenant: str, teams: [map]}, bufferSize: int(int32), jsonWorkers: int(int32), sendWorkers: int(int32), groupSize: int(int32), groupDuration: int(int64), filtering: map{include: [map], exclude: [map]}, projection: map, config: any}
@errors {400, 401, 404}

@endpoint DELETE /api/data-exporter-configs/{dataExporterConfigId}
@required {dataExporterConfigId: str}
@returns(200) {deleted: bool}
@errors {400, 401, 404}

@endpoint GET /api/data-exporter-configs
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/data-exporter-configs
@optional {enabled: str, typ: str(kafka/pulsar/file/mailer/elastic/console/custom), id: str, name: str, desc: str, metadata: map, location: map{tenant!: str, teams!: [map]}, bufferSize: int(int32), jsonWorkers: int(int32), sendWorkers: int(int32), groupSize: int(int32), groupDuration: int(int64), filtering: map{include: [map], exclude: [map]}, projection: map, config: any}
@returns(200) {enabled: str, typ: str, id: str, name: str, desc: str, metadata: map, location: map{tenant: str, teams: [map]}, bufferSize: int(int32), jsonWorkers: int(int32), sendWorkers: int(int32), groupSize: int(int32), groupDuration: int(int64), filtering: map{include: [map], exclude: [map]}, projection: map, config: any}
@errors {400, 401, 404}

@endpoint GET /api/certificates
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/certificates
@required {id: str, chain: str, privateKey: str, caRef: str, autoRenew: str, domain: str, selfSigned: str, ca: str, valid: str, subject: str, from: str, to: str}
@returns(200) {id: str, chain: str, privateKey: str, caRef: str, autoRenew: str, domain: str, selfSigned: str, ca: str, valid: str, subject: str, from: str, to: str}
@errors {400, 401, 404}

@endpoint GET /api/certificates/{id}
@required {id: str}
@returns(200) {id: str, chain: str, privateKey: str, caRef: str, autoRenew: str, domain: str, selfSigned: str, ca: str, valid: str, subject: str, from: str, to: str}
@errors {400, 401, 404}

@endpoint DELETE /api/certificates/{id}
@required {id: str}
@returns(200) {deleted: bool}
@errors {400, 401, 404}

@endpoint PUT /api/certificates/{id}
@required {id: str, id: str, chain: str, privateKey: str, caRef: str, autoRenew: str, domain: str, selfSigned: str, ca: str, valid: str, subject: str, from: str, to: str}
@returns(200) {id: str, chain: str, privateKey: str, caRef: str, autoRenew: str, domain: str, selfSigned: str, ca: str, valid: str, subject: str, from: str, to: str}
@errors {400, 401, 404}

@endpoint PATCH /api/certificates/{id}
@required {id: str}
@returns(200) {id: str, chain: str, privateKey: str, caRef: str, autoRenew: str, domain: str, selfSigned: str, ca: str, valid: str, subject: str, from: str, to: str}
@errors {400, 401, 404}

@endpoint GET /api/client-validators
@returns(200)
@errors {400, 401, 404}

@endpoint POST /api/client-validators
@required {id: str, name: str, description: str, url: str, host: str, goodTtl: int(int64), badTtl: int(int64), method: str, path: str, timeout: int(int64), noCache: bool, alwaysValid: bool, headers: map}
@returns(200) {id: str, name: str, description: str, url: str, host: str, goodTtl: int(int64), badTtl: int(int64), method: str, path: str, timeout: int(int64), noCache: bool, alwaysValid: bool, headers: map}
@errors {400, 401, 404}

@endpoint GET /api/client-validators/{id}
@required {id: str}
@returns(200) {id: str, name: str, description: str, url: str, host: str, goodTtl: int(int64), badTtl: int(int64), method: str, path: str, timeout: int(int64), noCache: bool, alwaysValid: bool, headers: map}
@errors {400, 401, 404}

@endpoint DELETE /api/client-validators/{id}
@required {id: str}
@returns(200) {deleted: bool}
@errors {400, 401, 404}

@endpoint PUT /api/client-validators/{id}
@required {id: str, id: str, name: str, description: str, url: str, host: str, goodTtl: int(int64), badTtl: int(int64), method: str, path: str, timeout: int(int64), noCache: bool, alwaysValid: bool, headers: map}
@returns(200) {id: str, name: str, description: str, url: str, host: str, goodTtl: int(int64), badTtl: int(int64), method: str, path: str, timeout: int(int64), noCache: bool, alwaysValid: bool, headers: map}
@errors {400, 401, 404}

@endpoint PATCH /api/client-validators/{id}
@required {id: str}
@returns(200) {id: str, name: str, description: str, url: str, host: str, goodTtl: int(int64), badTtl: int(int64), method: str, path: str, timeout: int(int64), noCache: bool, alwaysValid: bool, headers: map}
@errors {400, 401, 404}

@endpoint GET /api/snowmonkey/config
@returns(200) {enabled: bool, outageStrategy: str, includeUserFacingDescriptors: bool, dryRun: bool, timesPerDay: int(int32), startTime: str(time), stopTime: str(time), outageDurationFrom: int(int32), outageDurationTo: int(int32), targetGroups: [str], chaosConfig: map{enabled: bool, largeRequestFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, largeResponseFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, latencyInjectionFaultConfig: map{ratio: int(double), from: int(int32), to: int(int32)}, badResponsesFaultConfig: map{ratio: int(double), responses: [map]}}}
@errors {400, 401, 404}

@endpoint PUT /api/snowmonkey/config
@required {id: str, name: str}
@optional {description: str}
@returns(200) {enabled: bool, outageStrategy: str, includeUserFacingDescriptors: bool, dryRun: bool, timesPerDay: int(int32), startTime: str(time), stopTime: str(time), outageDurationFrom: int(int32), outageDurationTo: int(int32), targetGroups: [str], chaosConfig: map{enabled: bool, largeRequestFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, largeResponseFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, latencyInjectionFaultConfig: map{ratio: int(double), from: int(int32), to: int(int32)}, badResponsesFaultConfig: map{ratio: int(double), responses: [map]}}}
@errors {400, 401, 404}

@endpoint PATCH /api/snowmonkey/config
@required {id: str, name: str}
@optional {description: str}
@returns(200) {enabled: bool, outageStrategy: str, includeUserFacingDescriptors: bool, dryRun: bool, timesPerDay: int(int32), startTime: str(time), stopTime: str(time), outageDurationFrom: int(int32), outageDurationTo: int(int32), targetGroups: [str], chaosConfig: map{enabled: bool, largeRequestFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, largeResponseFaultConfig: map{ratio: int(double), additionalRequestSize: int(int32)}, latencyInjectionFaultConfig: map{ratio: int(double), from: int(int32), to: int(int32)}, badResponsesFaultConfig: map{ratio: int(double), responses: [map]}}}
@errors {400, 401, 404}

@endpoint GET /api/snowmonkey/outages
@returns(200)
@errors {400, 401, 404}

@endpoint DELETE /api/snowmonkey/outages
@returns(200) {done: bool}
@errors {400, 401, 404}

@endpoint POST /api/snowmonkey/_start
@returns(200) {done: bool}
@errors {400, 401, 404}

@endpoint POST /api/snowmonkey/_stop
@returns(200) {done: bool}
@errors {400, 401, 404}

@endpoint GET /api/live/{id}
@required {id: str}
@returns(200) {calls: int(int64), dataIn: int(int64), dataOut: int(int64), rate: int(double), duration: int(double), overhead: int(double), dataInRate: int(double), dataOutRate: int(double), concurrentHandledRequests: int(int64)}
@errors {400, 401, 404}

@endpoint GET /api/live
@returns(200) {calls: int(int64), dataIn: int(int64), dataOut: int(int64), rate: int(double), duration: int(double), overhead: int(double), dataInRate: int(double), dataOutRate: int(double), concurrentHandledRequests: int(int64)}
@errors {400, 401, 404}

@endpoint GET /api/globalconfig
@returns(200) {lines: [str], streamEntityOnly: bool, autoLinkToDefaultGroup: bool, limitConcurrentRequests: bool, maxConcurrentRequests: int(int64), maxHttp10ResponseSize: int(int64), useCircuitBreakers: bool, apiReadOnly: bool, u2fLoginOnly: bool, ipFiltering: map{whitelist: [str(ipv4)], blacklist: [str(ipv4)]}, throttlingQuota: int(int64), perIpThrottlingQuota: int(int64), elasticWritesConfigs: [map], elasticReadsConfig: map{clusterUri: str, index: str, type: str, user: str, password: str, headers: map}, analyticsWebhooks: [map], alertsWebhooks: [map], alertsEmails: [str(email)], endlessIpAddresses: [str(ipv4)], middleFingers: bool, maxLogsSize: int(int32), cleverSettings: map{consumerKey: str, consumerSecret: str, token: str, secret: str, orgaId: str}, mailerSettings: map{type: str, eu: bool, apiKey: str, domain: str, apiKeyPublic: str, apiKeyPrivate: str, url: str, header: map}, backofficeAuth0Config: map{clientId: str, clientSecret: str, domain: str, callbackUrl: str}, privateAppsAuth0Config: map{clientId: str, clientSecret: str, domain: str, callbackUrl: str}}
@errors {400, 401, 404}

@endpoint PUT /api/globalconfig
@required {streamEntityOnly: bool, autoLinkToDefaultGroup: bool, limitConcurrentRequests: bool, maxConcurrentRequests: int(int64), useCircuitBreakers: bool, apiReadOnly: bool, u2fLoginOnly: bool, ipFiltering: map{whitelist!: [str(ipv4)], blacklist!: [str(ipv4)]}, throttlingQuota: int(int64), perIpThrottlingQuota: int(int64), analyticsWebhooks: [map{url!: str(uri), headers!: map}], alertsWebhooks: [map{url!: str(uri), headers!: map}], alertsEmails: [str(email)], endlessIpAddresses: [str(ipv4)]}
@optional {lines: [str], maxHttp10ResponseSize: int(int64), elasticWritesConfigs: [map{clusterUri!: str, index!: str, type!: str, user!: str, password!: str, headers!: map}], elasticReadsConfig: map{clusterUri!: str, index!: str, type!: str, user!: str, password!: str, headers!: map}, middleFingers: bool, maxLogsSize: int(int32), cleverSettings: map{consumerKey!: str, consumerSecret!: str, token!: str, secret!: str, orgaId!: str}, mailerSettings: map{type: str, eu: bool, apiKey!: str, domain!: str, apiKeyPublic: str, apiKeyPrivate: str, url: str, header: map}, backofficeAuth0Config: map{clientId!: str, clientSecret!: str, domain!: str, callbackUrl!: str}, privateAppsAuth0Config: map{clientId!: str, clientSecret!: str, domain!: str, callbackUrl!: str}}
@returns(200) {lines: [str], streamEntityOnly: bool, autoLinkToDefaultGroup: bool, limitConcurrentRequests: bool, maxConcurrentRequests: int(int64), maxHttp10ResponseSize: int(int64), useCircuitBreakers: bool, apiReadOnly: bool, u2fLoginOnly: bool, ipFiltering: map{whitelist: [str(ipv4)], blacklist: [str(ipv4)]}, throttlingQuota: int(int64), perIpThrottlingQuota: int(int64), elasticWritesConfigs: [map], elasticReadsConfig: map{clusterUri: str, index: str, type: str, user: str, password: str, headers: map}, analyticsWebhooks: [map], alertsWebhooks: [map], alertsEmails: [str(email)], endlessIpAddresses: [str(ipv4)], middleFingers: bool, maxLogsSize: int(int32), cleverSettings: map{consumerKey: str, consumerSecret: str, token: str, secret: str, orgaId: str}, mailerSettings: map{type: str, eu: bool, apiKey: str, domain: str, apiKeyPublic: str, apiKeyPrivate: str, url: str, header: map}, backofficeAuth0Config: map{clientId: str, clientSecret: str, domain: str, callbackUrl: str}, privateAppsAuth0Config: map{clientId: str, clientSecret: str, domain: str, callbackUrl: str}}
@errors {400, 401, 404}

@endpoint PATCH /api/globalconfig
@returns(200) {lines: [str], streamEntityOnly: bool, autoLinkToDefaultGroup: bool, limitConcurrentRequests: bool, maxConcurrentRequests: int(int64), maxHttp10ResponseSize: int(int64), useCircuitBreakers: bool, apiReadOnly: bool, u2fLoginOnly: bool, ipFiltering: map{whitelist: [str(ipv4)], blacklist: [str(ipv4)]}, throttlingQuota: int(int64), perIpThrottlingQuota: int(int64), elasticWritesConfigs: [map], elasticReadsConfig: map{clusterUri: str, index: str, type: str, user: str, password: str, headers: map}, analyticsWebhooks: [map], alertsWebhooks: [map], alertsEmails: [str(email)], endlessIpAddresses: [str(ipv4)], middleFingers: bool, maxLogsSize: int(int32), cleverSettings: map{consumerKey: str, consumerSecret: str, token: str, secret: str, orgaId: str}, mailerSettings: map{type: str, eu: bool, apiKey: str, domain: str, apiKeyPublic: str, apiKeyPrivate: str, url: str, header: map}, backofficeAuth0Config: map{clientId: str, clientSecret: str, domain: str, callbackUrl: str}, privateAppsAuth0Config: map{clientId: str, clientSecret: str, domain: str, callbackUrl: str}}
@errors {400, 401, 404}

@endpoint GET /api/otoroshi.json
@returns(200) {label: str, dateRaw: int(int64), date: str(date-time), stats: map{calls: int(int64), dataIn: int(int64), dataOut: int(int64)}, config: map{lines: [str], streamEntityOnly: bool, autoLinkToDefaultGroup: bool, limitConcurrentRequests: bool, maxConcurrentRequests: int(int64), maxHttp10ResponseSize: int(int64), useCircuitBreakers: bool, apiReadOnly: bool, u2fLoginOnly: bool, ipFiltering: map{whitelist: [str(ipv4)], blacklist: [str(ipv4)]}, throttlingQuota: int(int64), perIpThrottlingQuota: int(int64), elasticWritesConfigs: [map], elasticReadsConfig: map{clusterUri: str, index: str, type: str, user: str, password: str, headers: map}, analyticsWebhooks: [map], alertsWebhooks: [map], alertsEmails: [str(email)], endlessIpAddresses: [str(ipv4)], middleFingers: bool, maxLogsSize: int(int32), cleverSettings: map{consumerKey: str, consumerSecret: str, token: str, secret: str, orgaId: str}, mailerSettings: map{type: str, eu: bool, apiKey: str, domain: str, apiKeyPublic: str, apiKeyPrivate: str, url: str, header: map}, backofficeAuth0Config: map{clientId: str, clientSecret: str, domain: str, callbackUrl: str}, privateAppsAuth0Config: map{clientId: str, clientSecret: str, domain: str, callbackUrl: str}}, appConfig: map, admins: [map], simpleAdmins: [map], serviceGroups: [map], apiKeys: [map], serviceDescriptors: [map], errorTemplates: [map]}
@errors {400, 401, 404}

@endpoint POST /api/otoroshi.json
@required {label: str, dateRaw: int(int64), date: str(date-time), stats: map{calls!: int(int64), dataIn!: int(int64), dataOut!: int(int64)}, config: map{lines: [str], streamEntityOnly!: bool, autoLinkToDefaultGroup!: bool, limitConcurrentRequests!: bool, maxConcurrentRequests!: int(int64), maxHttp10ResponseSize: int(int64), useCircuitBreakers!: bool, apiReadOnly!: bool, u2fLoginOnly!: bool, ipFiltering!: map, throttlingQuota!: int(int64), perIpThrottlingQuota!: int(int64), elasticWritesConfigs: [map], elasticReadsConfig: map, analyticsWebhooks!: [map], alertsWebhooks!: [map], alertsEmails!: [str(email)], endlessIpAddresses!: [str(ipv4)], middleFingers: bool, maxLogsSize: int(int32), cleverSettings: map, mailerSettings: map, backofficeAuth0Config: map, privateAppsAuth0Config: map}, admins: [map{username!: str, label!: str, password!: str, createdAt!: int(int64), registration!: map}], simpleAdmins: [map{username!: str, label!: str, password!: str, createdAt!: int(int64)}], serviceGroups: [map{id!: str, name!: str, description: str}], apiKeys: [map{clientId!: str, clientSecret!: str, clientName!: str, authorizedEntities!: [str], enabled!: bool, throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}], serviceDescriptors: [map{id!: str(uuid), groups!: [str], name!: str, env!: str, domain!: str, subdomain!: str, targets!: [map], root!: str, matchingRoot: str, localHost: str, localScheme: str, redirectToLocal: bool, enabled!: bool, userFacing: bool, privateApp!: bool, forceHttps!: bool, maintenanceMode!: bool, buildMode!: bool, enforceSecureCommunication!: bool, sendOtoroshiHeadersBack: bool, xForwardedHeaders: bool, overrideHost: bool, secComExcludedPatterns: [str], publicPatterns: [str], privatePatterns: [str], ipFiltering: map, api: map, healthCheck: map, clientConfig: map, Canary: map, statsdConfig: map, chaosConfig: map, jwtVerifier: any, secComSettings: any, metadata: map, matchingHeaders: map, additionalHeaders: map, authConfigRef: str, transformerRef: str, clientValidatorRef: str, cors: map, redirection: map, gzip: map, headersVerification: map}], errorTemplates: [map{serviceId!: str, template40x!: str, template50x!: str, templateBuild!: str, templateMaintenance!: str, messages!: map}]}
@optional {appConfig: map}
@returns(200) {done: bool}
@errors {400, 401, 404}

@endpoint POST /api/import
@required {label: str, dateRaw: int(int64), date: str(date-time), stats: map{calls!: int(int64), dataIn!: int(int64), dataOut!: int(int64)}, config: map{lines: [str], streamEntityOnly!: bool, autoLinkToDefaultGroup!: bool, limitConcurrentRequests!: bool, maxConcurrentRequests!: int(int64), maxHttp10ResponseSize: int(int64), useCircuitBreakers!: bool, apiReadOnly!: bool, u2fLoginOnly!: bool, ipFiltering!: map, throttlingQuota!: int(int64), perIpThrottlingQuota!: int(int64), elasticWritesConfigs: [map], elasticReadsConfig: map, analyticsWebhooks!: [map], alertsWebhooks!: [map], alertsEmails!: [str(email)], endlessIpAddresses!: [str(ipv4)], middleFingers: bool, maxLogsSize: int(int32), cleverSettings: map, mailerSettings: map, backofficeAuth0Config: map, privateAppsAuth0Config: map}, admins: [map{username!: str, label!: str, password!: str, createdAt!: int(int64), registration!: map}], simpleAdmins: [map{username!: str, label!: str, password!: str, createdAt!: int(int64)}], serviceGroups: [map{id!: str, name!: str, description: str}], apiKeys: [map{clientId!: str, clientSecret!: str, clientName!: str, authorizedEntities!: [str], enabled!: bool, throttlingQuota: int(int64), dailyQuota: int(int64), monthlyQuota: int(int64), metadata: map}], serviceDescriptors: [map{id!: str(uuid), groups!: [str], name!: str, env!: str, domain!: str, subdomain!: str, targets!: [map], root!: str, matchingRoot: str, localHost: str, localScheme: str, redirectToLocal: bool, enabled!: bool, userFacing: bool, privateApp!: bool, forceHttps!: bool, maintenanceMode!: bool, buildMode!: bool, enforceSecureCommunication!: bool, sendOtoroshiHeadersBack: bool, xForwardedHeaders: bool, overrideHost: bool, secComExcludedPatterns: [str], publicPatterns: [str], privatePatterns: [str], ipFiltering: map, api: map, healthCheck: map, clientConfig: map, Canary: map, statsdConfig: map, chaosConfig: map, jwtVerifier: any, secComSettings: any, metadata: map, matchingHeaders: map, additionalHeaders: map, authConfigRef: str, transformerRef: str, clientValidatorRef: str, cors: map, redirection: map, gzip: map, headersVerification: map}], errorTemplates: [map{serviceId!: str, template40x!: str, template50x!: str, templateBuild!: str, templateMaintenance!: str, messages!: map}]}
@optional {appConfig: map}
@returns(200) {done: bool}
@errors {400, 401, 404}

@endgroup

@group health
@endpoint GET /health
@returns(200) {otoroshi: str, datastore: str}
@errors {400, 404}

@endgroup

@end