mirror of
https://github.com/xtool-org/xtool.git
synced 2026-02-04 11:53:30 +01:00
4581 lines
212 KiB
Swift
4581 lines
212 KiB
Swift
// Generated by swift-openapi-generator, do not modify.
|
|
@_spi(Generated) import OpenAPIRuntime
|
|
#if os(Linux)
|
|
@preconcurrency import struct Foundation.URL
|
|
@preconcurrency import struct Foundation.Data
|
|
@preconcurrency import struct Foundation.Date
|
|
#else
|
|
import struct Foundation.URL
|
|
import struct Foundation.Data
|
|
import struct Foundation.Date
|
|
#endif
|
|
import HTTPTypes
|
|
public struct DeveloperAPIClient: APIProtocol {
|
|
/// The underlying HTTP client.
|
|
private let client: UniversalClient
|
|
/// Creates a new client.
|
|
/// - Parameters:
|
|
/// - serverURL: The server URL that the client connects to. Any server
|
|
/// URLs defined in the OpenAPI document are available as static methods
|
|
/// on the ``Servers`` type.
|
|
/// - configuration: A set of configuration values for the client.
|
|
/// - transport: A transport that performs HTTP operations.
|
|
/// - middlewares: A list of middlewares to call before the transport.
|
|
public init(
|
|
serverURL: Foundation.URL,
|
|
configuration: Configuration = .init(),
|
|
transport: any ClientTransport,
|
|
middlewares: [any ClientMiddleware] = []
|
|
) {
|
|
self.client = .init(
|
|
serverURL: serverURL,
|
|
configuration: configuration,
|
|
transport: transport,
|
|
middlewares: middlewares
|
|
)
|
|
}
|
|
private var converter: Converter {
|
|
client.converter
|
|
}
|
|
/// - Remark: HTTP `POST /v1/bundleIdCapabilities`.
|
|
/// - Remark: Generated from `#/paths//v1/bundleIdCapabilities/post(bundleIdCapabilities_createInstance)`.
|
|
public func bundleIdCapabilities_createInstance(_ input: Operations.bundleIdCapabilities_createInstance.Input) async throws -> Operations.bundleIdCapabilities_createInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.bundleIdCapabilities_createInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/bundleIdCapabilities",
|
|
parameters: []
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .post
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
let body: OpenAPIRuntime.HTTPBody?
|
|
switch input.body {
|
|
case let .json(value):
|
|
body = try converter.setRequiredRequestBodyAsJSON(
|
|
value,
|
|
headerFields: &request.headerFields,
|
|
contentType: "application/json; charset=utf-8"
|
|
)
|
|
}
|
|
return (request, body)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_createInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_createInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_createInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 422:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_createInstance.Output.UnprocessableContent.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unprocessableContent(.init(body: body))
|
|
case 201:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_createInstance.Output.Created.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.BundleIdCapabilityResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .created(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_createInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `PATCH /v1/bundleIdCapabilities/{id}`.
|
|
/// - Remark: Generated from `#/paths//v1/bundleIdCapabilities/{id}/patch(bundleIdCapabilities_updateInstance)`.
|
|
public func bundleIdCapabilities_updateInstance(_ input: Operations.bundleIdCapabilities_updateInstance.Input) async throws -> Operations.bundleIdCapabilities_updateInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.bundleIdCapabilities_updateInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/bundleIdCapabilities/{}",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .patch
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
let body: OpenAPIRuntime.HTTPBody?
|
|
switch input.body {
|
|
case let .json(value):
|
|
body = try converter.setRequiredRequestBodyAsJSON(
|
|
value,
|
|
headerFields: &request.headerFields,
|
|
contentType: "application/json; charset=utf-8"
|
|
)
|
|
}
|
|
return (request, body)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_updateInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_updateInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_updateInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_updateInstance.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 422:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_updateInstance.Output.UnprocessableContent.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unprocessableContent(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_updateInstance.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.BundleIdCapabilityResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_updateInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `DELETE /v1/bundleIdCapabilities/{id}`.
|
|
/// - Remark: Generated from `#/paths//v1/bundleIdCapabilities/{id}/delete(bundleIdCapabilities_deleteInstance)`.
|
|
public func bundleIdCapabilities_deleteInstance(_ input: Operations.bundleIdCapabilities_deleteInstance.Input) async throws -> Operations.bundleIdCapabilities_deleteInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.bundleIdCapabilities_deleteInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/bundleIdCapabilities/{}",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .delete
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_deleteInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_deleteInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_deleteInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_deleteInstance.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIdCapabilities_deleteInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
case 204:
|
|
return .noContent(.init())
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/bundleIds`.
|
|
/// - Remark: Generated from `#/paths//v1/bundleIds/get(bundleIds_getCollection)`.
|
|
public func bundleIds_getCollection(_ input: Operations.bundleIds_getCollection.Input) async throws -> Operations.bundleIds_getCollection.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.bundleIds_getCollection.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/bundleIds",
|
|
parameters: []
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[name]",
|
|
value: input.query.filter_lbrack_name_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[platform]",
|
|
value: input.query.filter_lbrack_platform_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[identifier]",
|
|
value: input.query.filter_lbrack_identifier_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[seedId]",
|
|
value: input.query.filter_lbrack_seedId_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[id]",
|
|
value: input.query.filter_lbrack_id_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "sort",
|
|
value: input.query.sort
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[bundleIds]",
|
|
value: input.query.fields_lbrack_bundleIds_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[profiles]",
|
|
value: input.query.fields_lbrack_profiles_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[bundleIdCapabilities]",
|
|
value: input.query.fields_lbrack_bundleIdCapabilities_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[apps]",
|
|
value: input.query.fields_lbrack_apps_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit",
|
|
value: input.query.limit
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "include",
|
|
value: input.query.include
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit[bundleIdCapabilities]",
|
|
value: input.query.limit_lbrack_bundleIdCapabilities_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit[profiles]",
|
|
value: input.query.limit_lbrack_profiles_rbrack_
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_getCollection.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_getCollection.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_getCollection.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_getCollection.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.BundleIdsResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `POST /v1/bundleIds`.
|
|
/// - Remark: Generated from `#/paths//v1/bundleIds/post(bundleIds_createInstance)`.
|
|
public func bundleIds_createInstance(_ input: Operations.bundleIds_createInstance.Input) async throws -> Operations.bundleIds_createInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.bundleIds_createInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/bundleIds",
|
|
parameters: []
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .post
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
let body: OpenAPIRuntime.HTTPBody?
|
|
switch input.body {
|
|
case let .json(value):
|
|
body = try converter.setRequiredRequestBodyAsJSON(
|
|
value,
|
|
headerFields: &request.headerFields,
|
|
contentType: "application/json; charset=utf-8"
|
|
)
|
|
}
|
|
return (request, body)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_createInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_createInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_createInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 422:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_createInstance.Output.UnprocessableContent.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unprocessableContent(.init(body: body))
|
|
case 201:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_createInstance.Output.Created.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.BundleIdResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .created(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_createInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/bundleIds/{id}`.
|
|
/// - Remark: Generated from `#/paths//v1/bundleIds/{id}/get(bundleIds_getInstance)`.
|
|
public func bundleIds_getInstance(_ input: Operations.bundleIds_getInstance.Input) async throws -> Operations.bundleIds_getInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.bundleIds_getInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/bundleIds/{}",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[bundleIds]",
|
|
value: input.query.fields_lbrack_bundleIds_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[profiles]",
|
|
value: input.query.fields_lbrack_profiles_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[bundleIdCapabilities]",
|
|
value: input.query.fields_lbrack_bundleIdCapabilities_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[apps]",
|
|
value: input.query.fields_lbrack_apps_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "include",
|
|
value: input.query.include
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit[bundleIdCapabilities]",
|
|
value: input.query.limit_lbrack_bundleIdCapabilities_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit[profiles]",
|
|
value: input.query.limit_lbrack_profiles_rbrack_
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_getInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_getInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_getInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_getInstance.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_getInstance.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.BundleIdResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `PATCH /v1/bundleIds/{id}`.
|
|
/// - Remark: Generated from `#/paths//v1/bundleIds/{id}/patch(bundleIds_updateInstance)`.
|
|
public func bundleIds_updateInstance(_ input: Operations.bundleIds_updateInstance.Input) async throws -> Operations.bundleIds_updateInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.bundleIds_updateInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/bundleIds/{}",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .patch
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
let body: OpenAPIRuntime.HTTPBody?
|
|
switch input.body {
|
|
case let .json(value):
|
|
body = try converter.setRequiredRequestBodyAsJSON(
|
|
value,
|
|
headerFields: &request.headerFields,
|
|
contentType: "application/json; charset=utf-8"
|
|
)
|
|
}
|
|
return (request, body)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_updateInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_updateInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_updateInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_updateInstance.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 422:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_updateInstance.Output.UnprocessableContent.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unprocessableContent(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_updateInstance.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.BundleIdResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_updateInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `DELETE /v1/bundleIds/{id}`.
|
|
/// - Remark: Generated from `#/paths//v1/bundleIds/{id}/delete(bundleIds_deleteInstance)`.
|
|
public func bundleIds_deleteInstance(_ input: Operations.bundleIds_deleteInstance.Input) async throws -> Operations.bundleIds_deleteInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.bundleIds_deleteInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/bundleIds/{}",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .delete
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_deleteInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_deleteInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_deleteInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_deleteInstance.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_deleteInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
case 204:
|
|
return .noContent(.init())
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/certificates`.
|
|
/// - Remark: Generated from `#/paths//v1/certificates/get(certificates_getCollection)`.
|
|
public func certificates_getCollection(_ input: Operations.certificates_getCollection.Input) async throws -> Operations.certificates_getCollection.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.certificates_getCollection.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/certificates",
|
|
parameters: []
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[displayName]",
|
|
value: input.query.filter_lbrack_displayName_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[certificateType]",
|
|
value: input.query.filter_lbrack_certificateType_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[serialNumber]",
|
|
value: input.query.filter_lbrack_serialNumber_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[id]",
|
|
value: input.query.filter_lbrack_id_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "sort",
|
|
value: input.query.sort
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[certificates]",
|
|
value: input.query.fields_lbrack_certificates_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit",
|
|
value: input.query.limit
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_getCollection.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_getCollection.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_getCollection.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_getCollection.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.CertificatesResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `POST /v1/certificates`.
|
|
/// - Remark: Generated from `#/paths//v1/certificates/post(certificates_createInstance)`.
|
|
public func certificates_createInstance(_ input: Operations.certificates_createInstance.Input) async throws -> Operations.certificates_createInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.certificates_createInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/certificates",
|
|
parameters: []
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .post
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
let body: OpenAPIRuntime.HTTPBody?
|
|
switch input.body {
|
|
case let .json(value):
|
|
body = try converter.setRequiredRequestBodyAsJSON(
|
|
value,
|
|
headerFields: &request.headerFields,
|
|
contentType: "application/json; charset=utf-8"
|
|
)
|
|
}
|
|
return (request, body)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_createInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_createInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_createInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 422:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_createInstance.Output.UnprocessableContent.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unprocessableContent(.init(body: body))
|
|
case 201:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_createInstance.Output.Created.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.CertificateResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .created(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_createInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/certificates/{id}`.
|
|
/// - Remark: Generated from `#/paths//v1/certificates/{id}/get(certificates_getInstance)`.
|
|
public func certificates_getInstance(_ input: Operations.certificates_getInstance.Input) async throws -> Operations.certificates_getInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.certificates_getInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/certificates/{}",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[certificates]",
|
|
value: input.query.fields_lbrack_certificates_rbrack_
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_getInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_getInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_getInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_getInstance.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_getInstance.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.CertificateResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `DELETE /v1/certificates/{id}`.
|
|
/// - Remark: Generated from `#/paths//v1/certificates/{id}/delete(certificates_deleteInstance)`.
|
|
public func certificates_deleteInstance(_ input: Operations.certificates_deleteInstance.Input) async throws -> Operations.certificates_deleteInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.certificates_deleteInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/certificates/{}",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .delete
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_deleteInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_deleteInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_deleteInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_deleteInstance.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.certificates_deleteInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
case 204:
|
|
return .noContent(.init())
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/devices`.
|
|
/// - Remark: Generated from `#/paths//v1/devices/get(devices_getCollection)`.
|
|
public func devices_getCollection(_ input: Operations.devices_getCollection.Input) async throws -> Operations.devices_getCollection.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.devices_getCollection.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/devices",
|
|
parameters: []
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[name]",
|
|
value: input.query.filter_lbrack_name_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[platform]",
|
|
value: input.query.filter_lbrack_platform_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[udid]",
|
|
value: input.query.filter_lbrack_udid_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[status]",
|
|
value: input.query.filter_lbrack_status_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[id]",
|
|
value: input.query.filter_lbrack_id_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "sort",
|
|
value: input.query.sort
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[devices]",
|
|
value: input.query.fields_lbrack_devices_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit",
|
|
value: input.query.limit
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_getCollection.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_getCollection.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_getCollection.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_getCollection.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.DevicesResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `POST /v1/devices`.
|
|
/// - Remark: Generated from `#/paths//v1/devices/post(devices_createInstance)`.
|
|
public func devices_createInstance(_ input: Operations.devices_createInstance.Input) async throws -> Operations.devices_createInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.devices_createInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/devices",
|
|
parameters: []
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .post
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
let body: OpenAPIRuntime.HTTPBody?
|
|
switch input.body {
|
|
case let .json(value):
|
|
body = try converter.setRequiredRequestBodyAsJSON(
|
|
value,
|
|
headerFields: &request.headerFields,
|
|
contentType: "application/json; charset=utf-8"
|
|
)
|
|
}
|
|
return (request, body)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_createInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_createInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_createInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 422:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_createInstance.Output.UnprocessableContent.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unprocessableContent(.init(body: body))
|
|
case 201:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_createInstance.Output.Created.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.DeviceResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .created(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_createInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/devices/{id}`.
|
|
/// - Remark: Generated from `#/paths//v1/devices/{id}/get(devices_getInstance)`.
|
|
public func devices_getInstance(_ input: Operations.devices_getInstance.Input) async throws -> Operations.devices_getInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.devices_getInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/devices/{}",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[devices]",
|
|
value: input.query.fields_lbrack_devices_rbrack_
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_getInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_getInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_getInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_getInstance.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_getInstance.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.DeviceResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `PATCH /v1/devices/{id}`.
|
|
/// - Remark: Generated from `#/paths//v1/devices/{id}/patch(devices_updateInstance)`.
|
|
public func devices_updateInstance(_ input: Operations.devices_updateInstance.Input) async throws -> Operations.devices_updateInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.devices_updateInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/devices/{}",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .patch
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
let body: OpenAPIRuntime.HTTPBody?
|
|
switch input.body {
|
|
case let .json(value):
|
|
body = try converter.setRequiredRequestBodyAsJSON(
|
|
value,
|
|
headerFields: &request.headerFields,
|
|
contentType: "application/json; charset=utf-8"
|
|
)
|
|
}
|
|
return (request, body)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_updateInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_updateInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_updateInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_updateInstance.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 422:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_updateInstance.Output.UnprocessableContent.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unprocessableContent(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_updateInstance.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.DeviceResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.devices_updateInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/profiles`.
|
|
/// - Remark: Generated from `#/paths//v1/profiles/get(profiles_getCollection)`.
|
|
public func profiles_getCollection(_ input: Operations.profiles_getCollection.Input) async throws -> Operations.profiles_getCollection.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.profiles_getCollection.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/profiles",
|
|
parameters: []
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[name]",
|
|
value: input.query.filter_lbrack_name_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[profileType]",
|
|
value: input.query.filter_lbrack_profileType_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[profileState]",
|
|
value: input.query.filter_lbrack_profileState_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "filter[id]",
|
|
value: input.query.filter_lbrack_id_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "sort",
|
|
value: input.query.sort
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[profiles]",
|
|
value: input.query.fields_lbrack_profiles_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[bundleIds]",
|
|
value: input.query.fields_lbrack_bundleIds_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[devices]",
|
|
value: input.query.fields_lbrack_devices_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[certificates]",
|
|
value: input.query.fields_lbrack_certificates_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit",
|
|
value: input.query.limit
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "include",
|
|
value: input.query.include
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit[certificates]",
|
|
value: input.query.limit_lbrack_certificates_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit[devices]",
|
|
value: input.query.limit_lbrack_devices_rbrack_
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_getCollection.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_getCollection.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_getCollection.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_getCollection.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ProfilesResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `POST /v1/profiles`.
|
|
/// - Remark: Generated from `#/paths//v1/profiles/post(profiles_createInstance)`.
|
|
public func profiles_createInstance(_ input: Operations.profiles_createInstance.Input) async throws -> Operations.profiles_createInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.profiles_createInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/profiles",
|
|
parameters: []
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .post
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
let body: OpenAPIRuntime.HTTPBody?
|
|
switch input.body {
|
|
case let .json(value):
|
|
body = try converter.setRequiredRequestBodyAsJSON(
|
|
value,
|
|
headerFields: &request.headerFields,
|
|
contentType: "application/json; charset=utf-8"
|
|
)
|
|
}
|
|
return (request, body)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_createInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_createInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_createInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 422:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_createInstance.Output.UnprocessableContent.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unprocessableContent(.init(body: body))
|
|
case 201:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_createInstance.Output.Created.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ProfileResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .created(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_createInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/profiles/{id}`.
|
|
/// - Remark: Generated from `#/paths//v1/profiles/{id}/get(profiles_getInstance)`.
|
|
public func profiles_getInstance(_ input: Operations.profiles_getInstance.Input) async throws -> Operations.profiles_getInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.profiles_getInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/profiles/{}",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[profiles]",
|
|
value: input.query.fields_lbrack_profiles_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[bundleIds]",
|
|
value: input.query.fields_lbrack_bundleIds_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[devices]",
|
|
value: input.query.fields_lbrack_devices_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[certificates]",
|
|
value: input.query.fields_lbrack_certificates_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "include",
|
|
value: input.query.include
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit[certificates]",
|
|
value: input.query.limit_lbrack_certificates_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit[devices]",
|
|
value: input.query.limit_lbrack_devices_rbrack_
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_getInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_getInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_getInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_getInstance.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_getInstance.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ProfileResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `DELETE /v1/profiles/{id}`.
|
|
/// - Remark: Generated from `#/paths//v1/profiles/{id}/delete(profiles_deleteInstance)`.
|
|
public func profiles_deleteInstance(_ input: Operations.profiles_deleteInstance.Input) async throws -> Operations.profiles_deleteInstance.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.profiles_deleteInstance.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/profiles/{}",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .delete
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_deleteInstance.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_deleteInstance.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_deleteInstance.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_deleteInstance.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 409:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_deleteInstance.Output.Conflict.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .conflict(.init(body: body))
|
|
case 204:
|
|
return .noContent(.init())
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/bundleIds/{id}/app`.
|
|
/// - Remark: Generated from `#/paths//v1/bundleIds/{id}/app/get(bundleIds_app_getToOneRelated)`.
|
|
public func bundleIds_app_getToOneRelated(_ input: Operations.bundleIds_app_getToOneRelated.Input) async throws -> Operations.bundleIds_app_getToOneRelated.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.bundleIds_app_getToOneRelated.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/bundleIds/{}/app",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[apps]",
|
|
value: input.query.fields_lbrack_apps_rbrack_
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_app_getToOneRelated.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_app_getToOneRelated.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_app_getToOneRelated.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_app_getToOneRelated.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_app_getToOneRelated.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.AppWithoutIncludesResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/bundleIds/{id}/bundleIdCapabilities`.
|
|
/// - Remark: Generated from `#/paths//v1/bundleIds/{id}/bundleIdCapabilities/get(bundleIds_bundleIdCapabilities_getToManyRelated)`.
|
|
public func bundleIds_bundleIdCapabilities_getToManyRelated(_ input: Operations.bundleIds_bundleIdCapabilities_getToManyRelated.Input) async throws -> Operations.bundleIds_bundleIdCapabilities_getToManyRelated.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.bundleIds_bundleIdCapabilities_getToManyRelated.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/bundleIds/{}/bundleIdCapabilities",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[bundleIdCapabilities]",
|
|
value: input.query.fields_lbrack_bundleIdCapabilities_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit",
|
|
value: input.query.limit
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_bundleIdCapabilities_getToManyRelated.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_bundleIdCapabilities_getToManyRelated.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_bundleIdCapabilities_getToManyRelated.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_bundleIdCapabilities_getToManyRelated.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_bundleIdCapabilities_getToManyRelated.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.BundleIdCapabilitiesWithoutIncludesResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/bundleIds/{id}/profiles`.
|
|
/// - Remark: Generated from `#/paths//v1/bundleIds/{id}/profiles/get(bundleIds_profiles_getToManyRelated)`.
|
|
public func bundleIds_profiles_getToManyRelated(_ input: Operations.bundleIds_profiles_getToManyRelated.Input) async throws -> Operations.bundleIds_profiles_getToManyRelated.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.bundleIds_profiles_getToManyRelated.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/bundleIds/{}/profiles",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[profiles]",
|
|
value: input.query.fields_lbrack_profiles_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit",
|
|
value: input.query.limit
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_profiles_getToManyRelated.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_profiles_getToManyRelated.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_profiles_getToManyRelated.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_profiles_getToManyRelated.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.bundleIds_profiles_getToManyRelated.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ProfilesWithoutIncludesResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/profiles/{id}/bundleId`.
|
|
/// - Remark: Generated from `#/paths//v1/profiles/{id}/bundleId/get(profiles_bundleId_getToOneRelated)`.
|
|
public func profiles_bundleId_getToOneRelated(_ input: Operations.profiles_bundleId_getToOneRelated.Input) async throws -> Operations.profiles_bundleId_getToOneRelated.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.profiles_bundleId_getToOneRelated.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/profiles/{}/bundleId",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[bundleIds]",
|
|
value: input.query.fields_lbrack_bundleIds_rbrack_
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_bundleId_getToOneRelated.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_bundleId_getToOneRelated.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_bundleId_getToOneRelated.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_bundleId_getToOneRelated.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_bundleId_getToOneRelated.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.BundleIdWithoutIncludesResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/profiles/{id}/certificates`.
|
|
/// - Remark: Generated from `#/paths//v1/profiles/{id}/certificates/get(profiles_certificates_getToManyRelated)`.
|
|
public func profiles_certificates_getToManyRelated(_ input: Operations.profiles_certificates_getToManyRelated.Input) async throws -> Operations.profiles_certificates_getToManyRelated.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.profiles_certificates_getToManyRelated.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/profiles/{}/certificates",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[certificates]",
|
|
value: input.query.fields_lbrack_certificates_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit",
|
|
value: input.query.limit
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_certificates_getToManyRelated.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_certificates_getToManyRelated.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_certificates_getToManyRelated.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_certificates_getToManyRelated.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_certificates_getToManyRelated.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.CertificatesWithoutIncludesResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
/// - Remark: HTTP `GET /v1/profiles/{id}/devices`.
|
|
/// - Remark: Generated from `#/paths//v1/profiles/{id}/devices/get(profiles_devices_getToManyRelated)`.
|
|
public func profiles_devices_getToManyRelated(_ input: Operations.profiles_devices_getToManyRelated.Input) async throws -> Operations.profiles_devices_getToManyRelated.Output {
|
|
try await client.send(
|
|
input: input,
|
|
forOperation: Operations.profiles_devices_getToManyRelated.id,
|
|
serializer: { input in
|
|
let path = try converter.renderedPath(
|
|
template: "/v1/profiles/{}/devices",
|
|
parameters: [
|
|
input.path.id
|
|
]
|
|
)
|
|
var request: HTTPTypes.HTTPRequest = .init(
|
|
soar_path: path,
|
|
method: .get
|
|
)
|
|
suppressMutabilityWarning(&request)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: false,
|
|
name: "fields[devices]",
|
|
value: input.query.fields_lbrack_devices_rbrack_
|
|
)
|
|
try converter.setQueryItemAsURI(
|
|
in: &request,
|
|
style: .form,
|
|
explode: true,
|
|
name: "limit",
|
|
value: input.query.limit
|
|
)
|
|
converter.setAcceptHeader(
|
|
in: &request.headerFields,
|
|
contentTypes: input.headers.accept
|
|
)
|
|
return (request, nil)
|
|
},
|
|
deserializer: { response, responseBody in
|
|
switch response.status.code {
|
|
case 400:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_devices_getToManyRelated.Output.BadRequest.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .badRequest(.init(body: body))
|
|
case 401:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_devices_getToManyRelated.Output.Unauthorized.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .unauthorized(.init(body: body))
|
|
case 403:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_devices_getToManyRelated.Output.Forbidden.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .forbidden(.init(body: body))
|
|
case 404:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_devices_getToManyRelated.Output.NotFound.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.ErrorResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .notFound(.init(body: body))
|
|
case 200:
|
|
let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
|
|
let body: Operations.profiles_devices_getToManyRelated.Output.Ok.Body
|
|
let chosenContentType = try converter.bestContentType(
|
|
received: contentType,
|
|
options: [
|
|
"application/json"
|
|
]
|
|
)
|
|
switch chosenContentType {
|
|
case "application/json":
|
|
body = try await converter.getResponseBodyAsJSON(
|
|
Components.Schemas.DevicesWithoutIncludesResponse.self,
|
|
from: responseBody,
|
|
transforming: { value in
|
|
.json(value)
|
|
}
|
|
)
|
|
default:
|
|
preconditionFailure("bestContentType chose an invalid content type.")
|
|
}
|
|
return .ok(.init(body: body))
|
|
default:
|
|
return .undocumented(
|
|
statusCode: response.status.code,
|
|
.init(
|
|
headerFields: response.headerFields,
|
|
body: responseBody
|
|
)
|
|
)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
}
|