// Generated by swift-openapi-generator, do not modify.
@_spi(Generated) import OpenAPIRuntime
#if os(Linux)
@preconcurrency import Foundation
#else
import Foundation
#endif
/// weather.gov API
public struct Client: 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: 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 }
    /// Returns all alerts
    ///
    /// - Remark: HTTP `GET /alerts`.
    /// - Remark: Generated from `#/paths//alerts/get(alerts_query)`.
    public func alerts_query(_ input: Operations.alerts_query.Input) async throws
        -> Operations.alerts_query.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.alerts_query.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(template: "/alerts", parameters: [])
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "active",
                    value: input.query.active
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "start",
                    value: input.query.start
                )
                try converter.setQueryItemAsText(in: &request, name: "end", value: input.query.end)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "point",
                    value: input.query.point
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "region_type",
                    value: input.query.region_type
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "limit",
                    value: input.query.limit
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "cursor",
                    value: input.query.cursor
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.AlertCollection.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.AlertCollection.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.AlertCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                case 301:
                    let headers: Operations.alerts_query.Output.MovedPermanently.Headers = .init()
                    return .movedPermanently(.init(headers: headers, body: nil))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns all currently active alerts
    ///
    /// - Remark: HTTP `GET /alerts/active`.
    /// - Remark: Generated from `#/paths//alerts/active/get(alerts_active)`.
    public func alerts_active(_ input: Operations.alerts_active.Input) async throws
        -> Operations.alerts_active.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.alerts_active.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/alerts/active",
                    parameters: []
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "point",
                    value: input.query.point
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "region_type",
                    value: input.query.region_type
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "limit",
                    value: input.query.limit
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.AlertCollection.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.AlertCollection.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.AlertCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                case 301:
                    let headers: Operations.alerts_active.Output.MovedPermanently.Headers = .init()
                    return .movedPermanently(.init(headers: headers, body: nil))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns info on the number of active alerts
    ///
    /// - Remark: HTTP `GET /alerts/active/count`.
    /// - Remark: Generated from `#/paths//alerts/active/count/get(alerts_active_count)`.
    public func alerts_active_count(_ input: Operations.alerts_active_count.Input) async throws
        -> Operations.alerts_active_count.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.alerts_active_count.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/alerts/active/count",
                    parameters: []
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.alerts_active_count.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.alerts_active_count.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Operations.alerts_active_count.Output.Ok.Body.jsonPayload.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns active alerts for the given NWS public zone or county
    ///
    /// - Remark: HTTP `GET /alerts/active/zone/{zoneId}`.
    /// - Remark: Generated from `#/paths//alerts/active/zone/{zoneId}/get(alerts_active_zone)`.
    public func alerts_active_zone(_ input: Operations.alerts_active_zone.Input) async throws
        -> Operations.alerts_active_zone.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.alerts_active_zone.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/alerts/active/zone/{}",
                    parameters: [input.path.zoneId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.AlertCollection.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.AlertCollection.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.AlertCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns active alerts for the given area (state or marine area)
    ///
    /// - Remark: HTTP `GET /alerts/active/area/{area}`.
    /// - Remark: Generated from `#/paths//alerts/active/area/{area}/get(alerts_active_area)`.
    public func alerts_active_area(_ input: Operations.alerts_active_area.Input) async throws
        -> Operations.alerts_active_area.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.alerts_active_area.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/alerts/active/area/{}",
                    parameters: [input.path.area]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.AlertCollection.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.AlertCollection.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.AlertCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns active alerts for the given marine region
    ///
    /// - Remark: HTTP `GET /alerts/active/region/{region}`.
    /// - Remark: Generated from `#/paths//alerts/active/region/{region}/get(alerts_active_region)`.
    public func alerts_active_region(_ input: Operations.alerts_active_region.Input) async throws
        -> Operations.alerts_active_region.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.alerts_active_region.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/alerts/active/region/{}",
                    parameters: [input.path.region]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.AlertCollection.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.AlertCollection.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.AlertCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of alert types
    ///
    /// - Remark: HTTP `GET /alerts/types`.
    /// - Remark: Generated from `#/paths//alerts/types/get(alerts_types)`.
    public func alerts_types(_ input: Operations.alerts_types.Input) async throws
        -> Operations.alerts_types.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.alerts_types.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/alerts/types",
                    parameters: []
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.alerts_types.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.alerts_types.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Operations.alerts_types.Output.Ok.Body.jsonPayload.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a specific alert
    ///
    /// - Remark: HTTP `GET /alerts/{id}`.
    /// - Remark: Generated from `#/paths//alerts/{id}/get(alerts_single)`.
    public func alerts_single(_ input: Operations.alerts_single.Input) async throws
        -> Operations.alerts_single.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.alerts_single.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/alerts/{}",
                    parameters: [input.path.id]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.alerts_single.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.alerts_single.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.AlertGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns metadata about a Center Weather Service Unit
    ///
    /// - Remark: HTTP `GET /aviation/cwsus/{cwsuId}`.
    /// - Remark: Generated from `#/paths//aviation/cwsus/{cwsuId}/get(cwsu)`.
    public func cwsu(_ input: Operations.cwsu.Input) async throws -> Operations.cwsu.Output {
        try await client.send(
            input: input,
            forOperation: Operations.cwsu.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/aviation/cwsus/{}",
                    parameters: [input.path.cwsuId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.cwsu.Output.Ok.Headers = .init()
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.cwsu.Output.Ok.Body = try converter.getResponseBodyAsJSON(
                        Components.Schemas.CenterWeatherServiceUnitJsonLd.self,
                        from: response.body,
                        transforming: { value in .json(value) }
                    )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of Center Weather Advisories from a CWSU
    ///
    /// - Remark: HTTP `GET /aviation/cwsus/{cwsuId}/cwas`.
    /// - Remark: Generated from `#/paths//aviation/cwsus/{cwsuId}/cwas/get(cwas)`.
    public func cwas(_ input: Operations.cwas.Input) async throws -> Operations.cwas.Output {
        try await client.send(
            input: input,
            forOperation: Operations.cwas.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/aviation/cwsus/{}/cwas",
                    parameters: [input.path.cwsuId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.cwas.Output.Ok.Headers = .init()
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.cwas.Output.Ok.Body = try converter.getResponseBodyAsJSON(
                        Components.Schemas.CenterWeatherAdvisoryCollectionGeoJson.self,
                        from: response.body,
                        transforming: { value in .json(value) }
                    )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of Center Weather Advisories from a CWSU
    ///
    /// - Remark: HTTP `GET /aviation/cwsus/{cwsuId}/cwas/{date}/{sequence}`.
    /// - Remark: Generated from `#/paths//aviation/cwsus/{cwsuId}/cwas/{date}/{sequence}/get(cwa)`.
    public func cwa(_ input: Operations.cwa.Input) async throws -> Operations.cwa.Output {
        try await client.send(
            input: input,
            forOperation: Operations.cwa.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/aviation/cwsus/{}/cwas/{}/{}",
                    parameters: [input.path.cwsuId, input.path.date, input.path.sequence]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.cwa.Output.Ok.Headers = .init()
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.cwa.Output.Ok.Body = try converter.getResponseBodyAsJSON(
                        Components.Schemas.CenterWeatherAdvisoryGeoJson.self,
                        from: response.body,
                        transforming: { value in .json(value) }
                    )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of SIGMET/AIRMETs
    ///
    /// - Remark: HTTP `GET /aviation/sigmets`.
    /// - Remark: Generated from `#/paths//aviation/sigmets/get(sigmetQuery)`.
    public func sigmetQuery(_ input: Operations.sigmetQuery.Input) async throws
        -> Operations.sigmetQuery.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.sigmetQuery.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/aviation/sigmets",
                    parameters: []
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "start",
                    value: input.query.start
                )
                try converter.setQueryItemAsText(in: &request, name: "end", value: input.query.end)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "date",
                    value: input.query.date
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "atsu",
                    value: input.query.atsu
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "sequence",
                    value: input.query.sequence
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.sigmetQuery.Output.Ok.Headers = .init()
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.sigmetQuery.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.SigmetCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of SIGMET/AIRMETs for the specified ATSU
    ///
    /// - Remark: HTTP `GET /aviation/sigmets/{atsu}`.
    /// - Remark: Generated from `#/paths//aviation/sigmets/{atsu}/get(sigmetsByATSU)`.
    public func sigmetsByATSU(_ input: Operations.sigmetsByATSU.Input) async throws
        -> Operations.sigmetsByATSU.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.sigmetsByATSU.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/aviation/sigmets/{}",
                    parameters: [input.path.atsu]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.sigmetsByATSU.Output.Ok.Headers = .init()
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.sigmetsByATSU.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.SigmetCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of SIGMET/AIRMETs for the specified ATSU for the specified date
    ///
    /// - Remark: HTTP `GET /aviation/sigmets/{atsu}/{date}`.
    /// - Remark: Generated from `#/paths//aviation/sigmets/{atsu}/{date}/get(sigmetsByATSUByDate)`.
    public func sigmetsByATSUByDate(_ input: Operations.sigmetsByATSUByDate.Input) async throws
        -> Operations.sigmetsByATSUByDate.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.sigmetsByATSUByDate.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/aviation/sigmets/{}/{}",
                    parameters: [input.path.atsu, input.path.date]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.sigmetsByATSUByDate.Output.Ok.Headers = .init()
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.sigmetsByATSUByDate.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.SigmetCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a specific SIGMET/AIRMET
    ///
    /// - Remark: HTTP `GET /aviation/sigmets/{atsu}/{date}/{time}`.
    /// - Remark: Generated from `#/paths//aviation/sigmets/{atsu}/{date}/{time}/get(sigmet)`.
    public func sigmet(_ input: Operations.sigmet.Input) async throws -> Operations.sigmet.Output {
        try await client.send(
            input: input,
            forOperation: Operations.sigmet.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/aviation/sigmets/{}/{}/{}",
                    parameters: [input.path.atsu, input.path.date, input.path.time]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.sigmet.Output.Ok.Headers = .init()
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.sigmet.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.SigmetGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns glossary terms
    ///
    /// - Remark: HTTP `GET /glossary`.
    /// - Remark: Generated from `#/paths//glossary/get(glossary)`.
    public func glossary(_ input: Operations.glossary.Input) async throws
        -> Operations.glossary.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.glossary.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(template: "/glossary", parameters: [])
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.glossary.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.glossary.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Operations.glossary.Output.Ok.Body.jsonPayload.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns raw numerical forecast data for a 2.5km grid area
    ///
    /// - Remark: HTTP `GET /gridpoints/{wfo}/{x},{y}`.
    /// - Remark: Generated from `#/paths//gridpoints/{wfo}/{x},{y}/get(gridpoint)`.
    public func gridpoint(_ input: Operations.gridpoint.Input) async throws
        -> Operations.gridpoint.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.gridpoint.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/gridpoints/{}/{},{}",
                    parameters: [input.path.wfo, input.path.x, input.path.y]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.gridpoint.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.gridpoint.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.GridpointGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a textual forecast for a 2.5km grid area
    ///
    /// - Remark: HTTP `GET /gridpoints/{wfo}/{x},{y}/forecast`.
    /// - Remark: Generated from `#/paths//gridpoints/{wfo}/{x},{y}/forecast/get(gridpoint_forecast)`.
    public func gridpoint_forecast(_ input: Operations.gridpoint_forecast.Input) async throws
        -> Operations.gridpoint_forecast.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.gridpoint_forecast.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/gridpoints/{}/{},{}/forecast",
                    parameters: [input.path.wfo, input.path.x, input.path.y]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "Feature-Flags",
                    value: input.headers.Feature_Flags
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "units",
                    value: input.query.units
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.GridpointForecast.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.GridpointForecast.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.GridpointForecastGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a textual hourly forecast for a 2.5km grid area
    ///
    /// - Remark: HTTP `GET /gridpoints/{wfo}/{x},{y}/forecast/hourly`.
    /// - Remark: Generated from `#/paths//gridpoints/{wfo}/{x},{y}/forecast/hourly/get(gridpoint_forecast_hourly)`.
    public func gridpoint_forecast_hourly(_ input: Operations.gridpoint_forecast_hourly.Input)
        async throws -> Operations.gridpoint_forecast_hourly.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.gridpoint_forecast_hourly.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/gridpoints/{}/{},{}/forecast/hourly",
                    parameters: [input.path.wfo, input.path.x, input.path.y]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "Feature-Flags",
                    value: input.headers.Feature_Flags
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "units",
                    value: input.query.units
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.GridpointForecast.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.GridpointForecast.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.GridpointForecastGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of observation stations usable for a given 2.5km grid area
    ///
    /// - Remark: HTTP `GET /gridpoints/{wfo}/{x},{y}/stations`.
    /// - Remark: Generated from `#/paths//gridpoints/{wfo}/{x},{y}/stations/get(gridpoint_stations)`.
    public func gridpoint_stations(_ input: Operations.gridpoint_stations.Input) async throws
        -> Operations.gridpoint_stations.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.gridpoint_stations.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/gridpoints/{}/{},{}/stations",
                    parameters: [input.path.wfo, input.path.x, input.path.y]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "limit",
                    value: input.query.limit
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "cursor",
                    value: input.query.cursor
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.ObservationStationCollection.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.ObservationStationCollection.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ObservationStationCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a forecast icon. Icon services in API are deprecated.
    ///
    /// - Remark: HTTP `GET /icons/{set}/{timeOfDay}/{first}`.
    /// - Remark: Generated from `#/paths//icons/{set}/{timeOfDay}/{first}/get(icons)`.
    public func icons(_ input: Operations.icons.Input) async throws -> Operations.icons.Output {
        try await client.send(
            input: input,
            forOperation: Operations.icons.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/icons/{}/{}/{}",
                    parameters: [input.path.set, input.path.timeOfDay, input.path.first]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "fontsize",
                    value: input.query.fontsize
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "image/png, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.icons.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "image/png"
                    )
                    let body: Operations.icons.Output.Ok.Body =
                        try converter.getResponseBodyAsBinary(
                            Foundation.Data.self,
                            from: response.body,
                            transforming: { value in .binary(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a forecast icon. Icon services in API are deprecated.
    ///
    /// - Remark: HTTP `GET /icons/{set}/{timeOfDay}/{first}/{second}`.
    /// - Remark: Generated from `#/paths//icons/{set}/{timeOfDay}/{first}/{second}/get(iconsDualCondition)`.
    public func iconsDualCondition(_ input: Operations.iconsDualCondition.Input) async throws
        -> Operations.iconsDualCondition.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.iconsDualCondition.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/icons/{}/{}/{}/{}",
                    parameters: [
                        input.path.set, input.path.timeOfDay, input.path.first, input.path.second,
                    ]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "fontsize",
                    value: input.query.fontsize
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "image/png, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.iconsDualCondition.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "image/png"
                    )
                    let body: Operations.iconsDualCondition.Output.Ok.Body =
                        try converter.getResponseBodyAsBinary(
                            Foundation.Data.self,
                            from: response.body,
                            transforming: { value in .binary(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of icon codes and textual descriptions. Icon services in API are deprecated.
    ///
    /// - Remark: HTTP `GET /icons`.
    /// - Remark: Generated from `#/paths//icons/get(icons_summary)`.
    public func icons_summary(_ input: Operations.icons_summary.Input) async throws
        -> Operations.icons_summary.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.icons_summary.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(template: "/icons", parameters: [])
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.icons_summary.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.icons_summary.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Operations.icons_summary.Output.Ok.Body.jsonPayload.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a thumbnail image for a satellite region. Image services in API are deprecated.
    ///
    /// - Remark: HTTP `GET /thumbnails/satellite/{area}`.
    /// - Remark: Generated from `#/paths//thumbnails/satellite/{area}/get(satellite_thumbnails)`.
    public func satellite_thumbnails(_ input: Operations.satellite_thumbnails.Input) async throws
        -> Operations.satellite_thumbnails.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.satellite_thumbnails.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/thumbnails/satellite/{}",
                    parameters: [input.path.area]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "image/jpeg, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.satellite_thumbnails.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "image/jpeg"
                    )
                    let body: Operations.satellite_thumbnails.Output.Ok.Body =
                        try converter.getResponseBodyAsBinary(
                            Foundation.Data.self,
                            from: response.body,
                            transforming: { value in .binary(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of observations for a given station
    ///
    /// - Remark: HTTP `GET /stations/{stationId}/observations`.
    /// - Remark: Generated from `#/paths//stations/{stationId}/observations/get(station_observation_list)`.
    public func station_observation_list(_ input: Operations.station_observation_list.Input)
        async throws -> Operations.station_observation_list.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.station_observation_list.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/stations/{}/observations",
                    parameters: [input.path.stationId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "start",
                    value: input.query.start
                )
                try converter.setQueryItemAsText(in: &request, name: "end", value: input.query.end)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "limit",
                    value: input.query.limit
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.ObservationCollection.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.ObservationCollection.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ObservationCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns the latest observation for a station
    ///
    /// - Remark: HTTP `GET /stations/{stationId}/observations/latest`.
    /// - Remark: Generated from `#/paths//stations/{stationId}/observations/latest/get(station_observation_latest)`.
    public func station_observation_latest(_ input: Operations.station_observation_latest.Input)
        async throws -> Operations.station_observation_latest.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.station_observation_latest.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/stations/{}/observations/latest",
                    parameters: [input.path.stationId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "require_qc",
                    value: input.query.require_qc
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.Observation.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.Observation.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ObservationGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a single observation.
    ///
    /// - Remark: HTTP `GET /stations/{stationId}/observations/{time}`.
    /// - Remark: Generated from `#/paths//stations/{stationId}/observations/{time}/get(station_observation_time)`.
    public func station_observation_time(_ input: Operations.station_observation_time.Input)
        async throws -> Operations.station_observation_time.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.station_observation_time.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/stations/{}/observations/{}",
                    parameters: [input.path.stationId, input.path.time]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.Observation.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.Observation.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ObservationGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns Terminal Aerodrome Forecasts for the specified airport station.
    ///
    /// - Remark: HTTP `GET /stations/{stationId}/tafs`.
    /// - Remark: Generated from `#/paths//stations/{stationId}/tafs/get(tafs)`.
    public func tafs(_ input: Operations.tafs.Input) async throws -> Operations.tafs.Output {
        try await client.send(
            input: input,
            forOperation: Operations.tafs.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/stations/{}/tafs",
                    parameters: [input.path.stationId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.tafs.Output.Ok.Headers = .init()
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.tafs.Output.Ok.Body = try converter.getResponseBodyAsJSON(
                        OpenAPIRuntime.OpenAPIValueContainer.self,
                        from: response.body,
                        transforming: { value in .json(value) }
                    )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a single Terminal Aerodrome Forecast.
    ///
    /// - Remark: HTTP `GET /stations/{stationId}/tafs/{date}/{time}`.
    /// - Remark: Generated from `#/paths//stations/{stationId}/tafs/{date}/{time}/get(taf)`.
    public func taf(_ input: Operations.taf.Input) async throws -> Operations.taf.Output {
        try await client.send(
            input: input,
            forOperation: Operations.taf.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/stations/{}/tafs/{}/{}",
                    parameters: [input.path.stationId, input.path.date, input.path.time]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/vnd.wmo.iwxxm+xml, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.taf.Output.Ok.Headers = .init()
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/vnd.wmo.iwxxm+xml"
                    )
                    let body: Operations.taf.Output.Ok.Body = try converter.getResponseBodyAsBinary(
                        Foundation.Data.self,
                        from: response.body,
                        transforming: { value in .binary(value) }
                    )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of observation stations.
    ///
    /// - Remark: HTTP `GET /stations`.
    /// - Remark: Generated from `#/paths//stations/get(obs_stations)`.
    public func obs_stations(_ input: Operations.obs_stations.Input) async throws
        -> Operations.obs_stations.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.obs_stations.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(template: "/stations", parameters: [])
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "limit",
                    value: input.query.limit
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "cursor",
                    value: input.query.cursor
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.ObservationStationCollection.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.ObservationStationCollection.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ObservationStationCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns metadata about a given observation station
    ///
    /// - Remark: HTTP `GET /stations/{stationId}`.
    /// - Remark: Generated from `#/paths//stations/{stationId}/get(obs_station)`.
    public func obs_station(_ input: Operations.obs_station.Input) async throws
        -> Operations.obs_station.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.obs_station.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/stations/{}",
                    parameters: [input.path.stationId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.obs_station.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.obs_station.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ObservationStationGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns metadata about a NWS forecast office
    ///
    /// - Remark: HTTP `GET /offices/{officeId}`.
    /// - Remark: Generated from `#/paths//offices/{officeId}/get(office)`.
    public func office(_ input: Operations.office.Input) async throws -> Operations.office.Output {
        try await client.send(
            input: input,
            forOperation: Operations.office.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/offices/{}",
                    parameters: [input.path.officeId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.office.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.office.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.Office.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a specific news headline for a given NWS office
    ///
    /// - Remark: HTTP `GET /offices/{officeId}/headlines/{headlineId}`.
    /// - Remark: Generated from `#/paths//offices/{officeId}/headlines/{headlineId}/get(office_headline)`.
    public func office_headline(_ input: Operations.office_headline.Input) async throws
        -> Operations.office_headline.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.office_headline.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/offices/{}/headlines/{}",
                    parameters: [input.path.officeId, input.path.headlineId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.office_headline.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.office_headline.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.OfficeHeadline.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of news headlines for a given NWS office
    ///
    /// - Remark: HTTP `GET /offices/{officeId}/headlines`.
    /// - Remark: Generated from `#/paths//offices/{officeId}/headlines/get(office_headlines)`.
    public func office_headlines(_ input: Operations.office_headlines.Input) async throws
        -> Operations.office_headlines.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.office_headlines.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/offices/{}/headlines",
                    parameters: [input.path.officeId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.office_headlines.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.office_headlines.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.OfficeHeadlineCollection.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns metadata about a given latitude/longitude point
    ///
    /// - Remark: HTTP `GET /points/{point}`.
    /// - Remark: Generated from `#/paths//points/{point}/get(point)`.
    public func point(_ input: Operations.point.Input) async throws -> Operations.point.Output {
        try await client.send(
            input: input,
            forOperation: Operations.point.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/points/{}",
                    parameters: [input.path.point]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.point.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.point.Output.Ok.Body = try converter.getResponseBodyAsJSON(
                        Components.Schemas.PointGeoJson.self,
                        from: response.body,
                        transforming: { value in .json(value) }
                    )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of observation stations for a given point
    ///
    /// - Remark: HTTP `GET /points/{point}/stations`.
    /// - Remark: Generated from `#/paths//points/{point}/stations/get(point_stations)`.
    public func point_stations(_ input: Operations.point_stations.Input) async throws
        -> Operations.point_stations.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.point_stations.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/points/{}/stations",
                    parameters: [input.path.point]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 301:
                    let headers: Operations.point_stations.Output.MovedPermanently.Headers = .init()
                    return .movedPermanently(.init(headers: headers, body: nil))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of radar servers
    ///
    /// - Remark: HTTP `GET /radar/servers`.
    /// - Remark: Generated from `#/paths//radar/servers/get(radar_servers)`.
    public func radar_servers(_ input: Operations.radar_servers.Input) async throws
        -> Operations.radar_servers.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.radar_servers.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/radar/servers",
                    parameters: []
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "reportingHost",
                    value: input.query.reportingHost
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.radar_servers.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.radar_servers.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            OpenAPIRuntime.OpenAPIValueContainer.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns metadata about a given radar server
    ///
    /// - Remark: HTTP `GET /radar/servers/{id}`.
    /// - Remark: Generated from `#/paths//radar/servers/{id}/get(radar_server)`.
    public func radar_server(_ input: Operations.radar_server.Input) async throws
        -> Operations.radar_server.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.radar_server.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/radar/servers/{}",
                    parameters: [input.path.id]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "reportingHost",
                    value: input.query.reportingHost
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.radar_server.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.radar_server.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            OpenAPIRuntime.OpenAPIValueContainer.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of radar stations
    ///
    /// - Remark: HTTP `GET /radar/stations`.
    /// - Remark: Generated from `#/paths//radar/stations/get(radar_stations)`.
    public func radar_stations(_ input: Operations.radar_stations.Input) async throws
        -> Operations.radar_stations.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.radar_stations.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/radar/stations",
                    parameters: []
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "reportingHost",
                    value: input.query.reportingHost
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "host",
                    value: input.query.host
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.radar_stations.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.radar_stations.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            OpenAPIRuntime.OpenAPIValueContainer.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns metadata about a given radar station
    ///
    /// - Remark: HTTP `GET /radar/stations/{stationId}`.
    /// - Remark: Generated from `#/paths//radar/stations/{stationId}/get(radar_station)`.
    public func radar_station(_ input: Operations.radar_station.Input) async throws
        -> Operations.radar_station.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.radar_station.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/radar/stations/{}",
                    parameters: [input.path.stationId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "reportingHost",
                    value: input.query.reportingHost
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "host",
                    value: input.query.host
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.radar_station.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.radar_station.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            OpenAPIRuntime.OpenAPIValueContainer.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns metadata about a given radar station alarms
    ///
    /// - Remark: HTTP `GET /radar/stations/{stationId}/alarms`.
    /// - Remark: Generated from `#/paths//radar/stations/{stationId}/alarms/get(radar_station_alarms)`.
    public func radar_station_alarms(_ input: Operations.radar_station_alarms.Input) async throws
        -> Operations.radar_station_alarms.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.radar_station_alarms.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/radar/stations/{}/alarms",
                    parameters: [input.path.stationId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.radar_station_alarms.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.radar_station_alarms.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            OpenAPIRuntime.OpenAPIValueContainer.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns metadata about a given radar queue
    ///
    /// - Remark: HTTP `GET /radar/queues/{host}`.
    /// - Remark: Generated from `#/paths//radar/queues/{host}/get(radar_queue)`.
    public func radar_queue(_ input: Operations.radar_queue.Input) async throws
        -> Operations.radar_queue.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.radar_queue.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/radar/queues/{}",
                    parameters: [input.path.host]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "limit",
                    value: input.query.limit
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "arrived",
                    value: input.query.arrived
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "created",
                    value: input.query.created
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "published",
                    value: input.query.published
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "station",
                    value: input.query.station
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "type",
                    value: input.query._type
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "feed",
                    value: input.query.feed
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "resolution",
                    value: input.query.resolution
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.radar_queue.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.radar_queue.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            OpenAPIRuntime.OpenAPIValueContainer.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns metadata about a given radar wind profiler
    ///
    /// - Remark: HTTP `GET /radar/profilers/{stationId}`.
    /// - Remark: Generated from `#/paths//radar/profilers/{stationId}/get(radar_profiler)`.
    public func radar_profiler(_ input: Operations.radar_profiler.Input) async throws
        -> Operations.radar_profiler.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.radar_profiler.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/radar/profilers/{}",
                    parameters: [input.path.stationId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "time",
                    value: input.query.time
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "interval",
                    value: input.query.interval
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.radar_profiler.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.radar_profiler.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            OpenAPIRuntime.OpenAPIValueContainer.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of text products
    ///
    /// - Remark: HTTP `GET /products`.
    /// - Remark: Generated from `#/paths//products/get(products_query)`.
    public func products_query(_ input: Operations.products_query.Input) async throws
        -> Operations.products_query.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.products_query.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(template: "/products", parameters: [])
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "start",
                    value: input.query.start
                )
                try converter.setQueryItemAsText(in: &request, name: "end", value: input.query.end)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "limit",
                    value: input.query.limit
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.products_query.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.products_query.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.TextProductCollection.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of valid text product issuance locations
    ///
    /// - Remark: HTTP `GET /products/locations`.
    /// - Remark: Generated from `#/paths//products/locations/get(product_locations)`.
    public func product_locations(_ input: Operations.product_locations.Input) async throws
        -> Operations.product_locations.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.product_locations.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/products/locations",
                    parameters: []
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.product_locations.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.product_locations.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.TextProductLocationCollection.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of valid text product types and codes
    ///
    /// - Remark: HTTP `GET /products/types`.
    /// - Remark: Generated from `#/paths//products/types/get(product_types)`.
    public func product_types(_ input: Operations.product_types.Input) async throws
        -> Operations.product_types.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.product_types.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/products/types",
                    parameters: []
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.product_types.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.product_types.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.TextProductTypeCollection.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a specific text product
    ///
    /// - Remark: HTTP `GET /products/{productId}`.
    /// - Remark: Generated from `#/paths//products/{productId}/get(product)`.
    public func product(_ input: Operations.product.Input) async throws -> Operations.product.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.product.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/products/{}",
                    parameters: [input.path.productId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.product.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.product.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.TextProduct.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of text products of a given type
    ///
    /// - Remark: HTTP `GET /products/types/{typeId}`.
    /// - Remark: Generated from `#/paths//products/types/{typeId}/get(products_type)`.
    public func products_type(_ input: Operations.products_type.Input) async throws
        -> Operations.products_type.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.products_type.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/products/types/{}",
                    parameters: [input.path.typeId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.products_type.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.products_type.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.TextProductCollection.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of valid text product issuance locations for a given product type
    ///
    /// - Remark: HTTP `GET /products/types/{typeId}/locations`.
    /// - Remark: Generated from `#/paths//products/types/{typeId}/locations/get(products_type_locations)`.
    public func products_type_locations(_ input: Operations.products_type_locations.Input)
        async throws -> Operations.products_type_locations.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.products_type_locations.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/products/types/{}/locations",
                    parameters: [input.path.typeId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.products_type_locations.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.products_type_locations.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.TextProductLocationCollection.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of valid text product types for a given issuance location
    ///
    /// - Remark: HTTP `GET /products/locations/{locationId}/types`.
    /// - Remark: Generated from `#/paths//products/locations/{locationId}/types/get(location_products)`.
    public func location_products(_ input: Operations.location_products.Input) async throws
        -> Operations.location_products.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.location_products.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/products/locations/{}/types",
                    parameters: [input.path.locationId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.location_products.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.location_products.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.TextProductTypeCollection.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of text products of a given type for a given issuance location
    ///
    /// - Remark: HTTP `GET /products/types/{typeId}/locations/{locationId}`.
    /// - Remark: Generated from `#/paths//products/types/{typeId}/locations/{locationId}/get(products_type_location)`.
    public func products_type_location(_ input: Operations.products_type_location.Input)
        async throws -> Operations.products_type_location.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.products_type_location.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/products/types/{}/locations/{}",
                    parameters: [input.path.typeId, input.path.locationId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/ld+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.products_type_location.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/ld+json"
                    )
                    let body: Operations.products_type_location.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.TextProductCollection.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of zones
    ///
    /// - Remark: HTTP `GET /zones`.
    /// - Remark: Generated from `#/paths//zones/get(zone_list)`.
    public func zone_list(_ input: Operations.zone_list.Input) async throws
        -> Operations.zone_list.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.zone_list.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(template: "/zones", parameters: [])
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "point",
                    value: input.query.point
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "include_geometry",
                    value: input.query.include_geometry
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "limit",
                    value: input.query.limit
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "effective",
                    value: input.query.effective
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.zone_list.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.zone_list.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ZoneCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of zones of a given type
    ///
    /// - Remark: HTTP `GET /zones/{type}`.
    /// - Remark: Generated from `#/paths//zones/{type}/get(zone_list_type)`.
    public func zone_list_type(_ input: Operations.zone_list_type.Input) async throws
        -> Operations.zone_list_type.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.zone_list_type.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/zones/{}",
                    parameters: [input.path._type]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "point",
                    value: input.query.point
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "include_geometry",
                    value: input.query.include_geometry
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "limit",
                    value: input.query.limit
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "effective",
                    value: input.query.effective
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.zone_list_type.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.zone_list_type.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ZoneCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns metadata about a given zone
    ///
    /// - Remark: HTTP `GET /zones/{type}/{zoneId}`.
    /// - Remark: Generated from `#/paths//zones/{type}/{zoneId}/get(zone)`.
    public func zone(_ input: Operations.zone.Input) async throws -> Operations.zone.Output {
        try await client.send(
            input: input,
            forOperation: Operations.zone.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/zones/{}/{}",
                    parameters: [input.path._type, input.path.zoneId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "effective",
                    value: input.query.effective
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.zone.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.zone.Output.Ok.Body = try converter.getResponseBodyAsJSON(
                        Components.Schemas.ZoneGeoJson.self,
                        from: response.body,
                        transforming: { value in .json(value) }
                    )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns the current zone forecast for a given zone
    ///
    /// - Remark: HTTP `GET /zones/{type}/{zoneId}/forecast`.
    /// - Remark: Generated from `#/paths//zones/{type}/{zoneId}/forecast/get(zone_forecast)`.
    public func zone_forecast(_ input: Operations.zone_forecast.Input) async throws
        -> Operations.zone_forecast.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.zone_forecast.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/zones/{}/{}/forecast",
                    parameters: [input.path._type, input.path.zoneId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.zone_forecast.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.zone_forecast.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ZoneForecastGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of observations for a given zone
    ///
    /// - Remark: HTTP `GET /zones/forecast/{zoneId}/observations`.
    /// - Remark: Generated from `#/paths//zones/forecast/{zoneId}/observations/get(zone_obs)`.
    public func zone_obs(_ input: Operations.zone_obs.Input) async throws
        -> Operations.zone_obs.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.zone_obs.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/zones/forecast/{}/observations",
                    parameters: [input.path.zoneId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "start",
                    value: input.query.start
                )
                try converter.setQueryItemAsText(in: &request, name: "end", value: input.query.end)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "limit",
                    value: input.query.limit
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Operations.zone_obs.Output.Ok.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Operations.zone_obs.Output.Ok.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ObservationCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
    /// Returns a list of observation stations for a given zone
    ///
    /// - Remark: HTTP `GET /zones/forecast/{zoneId}/stations`.
    /// - Remark: Generated from `#/paths//zones/forecast/{zoneId}/stations/get(zone_stations)`.
    public func zone_stations(_ input: Operations.zone_stations.Input) async throws
        -> Operations.zone_stations.Output
    {
        try await client.send(
            input: input,
            forOperation: Operations.zone_stations.id,
            serializer: { input in
                let path = try converter.renderedRequestPath(
                    template: "/zones/forecast/{}/stations",
                    parameters: [input.path.zoneId]
                )
                var request: OpenAPIRuntime.Request = .init(path: path, method: .get)
                suppressMutabilityWarning(&request)
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "limit",
                    value: input.query.limit
                )
                try converter.setQueryItemAsText(
                    in: &request,
                    name: "cursor",
                    value: input.query.cursor
                )
                try converter.setHeaderFieldAsText(
                    in: &request.headerFields,
                    name: "accept",
                    value: "application/geo+json, application/problem+json"
                )
                return request
            },
            deserializer: { response in
                switch response.statusCode {
                case 200:
                    let headers: Components.Responses.ObservationStationCollection.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/geo+json"
                    )
                    let body: Components.Responses.ObservationStationCollection.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ObservationStationCollectionGeoJson.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .ok(.init(headers: headers, body: body))
                default:
                    let headers: Components.Responses._Error.Headers = .init(
                        X_Correlation_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Correlation-Id",
                            as: Components.Headers.CorrelationId.self
                        ),
                        X_Request_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Request-Id",
                            as: Components.Headers.RequestId.self
                        ),
                        X_Server_Id: try converter.getOptionalHeaderFieldAsText(
                            in: response.headerFields,
                            name: "X-Server-Id",
                            as: Components.Headers.ServerId.self
                        )
                    )
                    try converter.validateContentTypeIfPresent(
                        in: response.headerFields,
                        substring: "application/problem+json"
                    )
                    let body: Components.Responses._Error.Body =
                        try converter.getResponseBodyAsJSON(
                            Components.Schemas.ProblemDetail.self,
                            from: response.body,
                            transforming: { value in .json(value) }
                        )
                    return .`default`(
                        statusCode: response.statusCode,
                        .init(headers: headers, body: body)
                    )
                }
            }
        )
    }
}