plexswift/Sources/Plexswift/internal/api/_ServerAPI.swift

// Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.


import Foundation

class _ServerAPI: ServerAPI {
    private let client: Client

    init(client: Client) {
        self.client = client
    }
    
    public func getServerCapabilities() async throws -> Response<Operations.GetServerCapabilitiesResponse> {
        return try await client.makeRequest(
            configureRequest: { configuration in
                try configureGetServerCapabilitiesRequest(with: configuration)
            },
            handleResponse: handleGetServerCapabilitiesResponse
        )
    }
    
    public func getServerPreferences() async throws -> Response<Operations.GetServerPreferencesResponse> {
        return try await client.makeRequest(
            configureRequest: { configuration in
                try configureGetServerPreferencesRequest(with: configuration)
            },
            handleResponse: handleGetServerPreferencesResponse
        )
    }
    
    public func getAvailableClients() async throws -> Response<Operations.GetAvailableClientsResponse> {
        return try await client.makeRequest(
            configureRequest: { configuration in
                try configureGetAvailableClientsRequest(with: configuration)
            },
            handleResponse: handleGetAvailableClientsResponse
        )
    }
    
    public func getDevices() async throws -> Response<Operations.GetDevicesResponse> {
        return try await client.makeRequest(
            configureRequest: { configuration in
                try configureGetDevicesRequest(with: configuration)
            },
            handleResponse: handleGetDevicesResponse
        )
    }
    
    public func getServerIdentity() async throws -> Response<Operations.GetServerIdentityResponse> {
        return try await client.makeRequest(
            configureRequest: { configuration in
                try configureGetServerIdentityRequest(with: configuration)
            },
            handleResponse: handleGetServerIdentityResponse
        )
    }
    
    public func getMyPlexAccount() async throws -> Response<Operations.GetMyPlexAccountResponse> {
        return try await client.makeRequest(
            configureRequest: { configuration in
                try configureGetMyPlexAccountRequest(with: configuration)
            },
            handleResponse: handleGetMyPlexAccountResponse
        )
    }
    
    public func getResizedPhoto(request: Operations.GetResizedPhotoRequest) async throws -> Response<Operations.GetResizedPhotoResponse> {
        return try await client.makeRequest(
            configureRequest: { configuration in
                try configureGetResizedPhotoRequest(with: configuration, request: request)
            },
            handleResponse: handleGetResizedPhotoResponse
        )
    }
    
    public func getMediaProviders(request: Operations.GetMediaProvidersRequest) async throws -> Response<Operations.GetMediaProvidersResponse> {
        return try await client.makeRequest(
            configureRequest: { configuration in
                try configureGetMediaProvidersRequest(with: configuration, request: request)
            },
            handleResponse: handleGetMediaProvidersResponse
        )
    }
    
    public func getServerList() async throws -> Response<Operations.GetServerListResponse> {
        return try await client.makeRequest(
            configureRequest: { configuration in
                try configureGetServerListRequest(with: configuration)
            },
            handleResponse: handleGetServerListResponse
        )
    }

}

// MARK: - Request Configuration

private func configureGetServerCapabilitiesRequest(with configuration: URLRequestConfiguration) throws {
    configuration.path = "/"
    configuration.method = .get
    configuration.telemetryHeader = .userAgent
}

private func configureGetServerPreferencesRequest(with configuration: URLRequestConfiguration) throws {
    configuration.path = "/:/prefs"
    configuration.method = .get
    configuration.telemetryHeader = .userAgent
}

private func configureGetAvailableClientsRequest(with configuration: URLRequestConfiguration) throws {
    configuration.path = "/clients"
    configuration.method = .get
    configuration.telemetryHeader = .userAgent
}

private func configureGetDevicesRequest(with configuration: URLRequestConfiguration) throws {
    configuration.path = "/devices"
    configuration.method = .get
    configuration.telemetryHeader = .userAgent
}

private func configureGetServerIdentityRequest(with configuration: URLRequestConfiguration) throws {
    configuration.path = "/identity"
    configuration.method = .get
    configuration.telemetryHeader = .userAgent
}

private func configureGetMyPlexAccountRequest(with configuration: URLRequestConfiguration) throws {
    configuration.path = "/myplex/account"
    configuration.method = .get
    configuration.telemetryHeader = .userAgent
}

private func configureGetResizedPhotoRequest(with configuration: URLRequestConfiguration, request: Operations.GetResizedPhotoRequest) throws {
    configuration.path = "/photo/:/transcode"
    configuration.method = .get
    configuration.queryParameterSerializable = request
    configuration.telemetryHeader = .userAgent
}

private func configureGetMediaProvidersRequest(with configuration: URLRequestConfiguration, request: Operations.GetMediaProvidersRequest) throws {
    configuration.path = "/media/providers"
    configuration.method = .get
    configuration.headerParameterSerializable = request
    configuration.telemetryHeader = .userAgent
}

private func configureGetServerListRequest(with configuration: URLRequestConfiguration) throws {
    configuration.path = "/servers"
    configuration.method = .get
    configuration.telemetryHeader = .userAgent
}

// MARK: - Response Handlers

private func handleGetServerCapabilitiesResponse(response: Client.APIResponse) throws -> Operations.GetServerCapabilitiesResponse {
    let httpResponse = response.httpResponse
    
    if httpResponse.statusCode == 200 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .object(try JSONDecoder().decode(Operations.GetServerCapabilitiesResponseBody.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 400 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .badRequest(try JSONDecoder().decode(Operations.GetServerCapabilitiesBadRequest.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 401 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .unauthorized(try JSONDecoder().decode(Operations.GetServerCapabilitiesUnauthorized.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    }

    return .empty
}

private func handleGetServerPreferencesResponse(response: Client.APIResponse) throws -> Operations.GetServerPreferencesResponse {
    let httpResponse = response.httpResponse
    
    if httpResponse.statusCode == 200 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .object(try JSONDecoder().decode(Operations.GetServerPreferencesResponseBody.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 400 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .badRequest(try JSONDecoder().decode(Operations.GetServerPreferencesBadRequest.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 401 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .unauthorized(try JSONDecoder().decode(Operations.GetServerPreferencesUnauthorized.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    }

    return .empty
}

private func handleGetAvailableClientsResponse(response: Client.APIResponse) throws -> Operations.GetAvailableClientsResponse {
    let httpResponse = response.httpResponse
    
    if httpResponse.statusCode == 200 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .object(try JSONDecoder().decode(Operations.GetAvailableClientsResponseBody.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 400 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .badRequest(try JSONDecoder().decode(Operations.GetAvailableClientsBadRequest.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 401 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .unauthorized(try JSONDecoder().decode(Operations.GetAvailableClientsUnauthorized.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    }

    return .empty
}

private func handleGetDevicesResponse(response: Client.APIResponse) throws -> Operations.GetDevicesResponse {
    let httpResponse = response.httpResponse
    
    if httpResponse.statusCode == 200 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .object(try JSONDecoder().decode(Operations.GetDevicesResponseBody.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 400 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .badRequest(try JSONDecoder().decode(Operations.GetDevicesBadRequest.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 401 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .unauthorized(try JSONDecoder().decode(Operations.GetDevicesUnauthorized.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    }

    return .empty
}

private func handleGetServerIdentityResponse(response: Client.APIResponse) throws -> Operations.GetServerIdentityResponse {
    let httpResponse = response.httpResponse
    
    if httpResponse.statusCode == 200 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .object(try JSONDecoder().decode(Operations.GetServerIdentityResponseBody.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 408 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .requestTimeout(try JSONDecoder().decode(Operations.GetServerIdentityRequestTimeout.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    }

    return .empty
}

private func handleGetMyPlexAccountResponse(response: Client.APIResponse) throws -> Operations.GetMyPlexAccountResponse {
    let httpResponse = response.httpResponse
    
    if httpResponse.statusCode == 200 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .object(try JSONDecoder().decode(Operations.GetMyPlexAccountResponseBody.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 400 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .badRequest(try JSONDecoder().decode(Operations.GetMyPlexAccountBadRequest.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 401 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .unauthorized(try JSONDecoder().decode(Operations.GetMyPlexAccountUnauthorized.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    }

    return .empty
}

private func handleGetResizedPhotoResponse(response: Client.APIResponse) throws -> Operations.GetResizedPhotoResponse {
    let httpResponse = response.httpResponse
    
    if httpResponse.statusCode == 200 { 
        return .empty
    } else if httpResponse.statusCode == 400 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .badRequest(try JSONDecoder().decode(Operations.GetResizedPhotoBadRequest.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 401 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .unauthorized(try JSONDecoder().decode(Operations.GetResizedPhotoUnauthorized.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    }

    return .empty
}

private func handleGetMediaProvidersResponse(response: Client.APIResponse) throws -> Operations.GetMediaProvidersResponse {
    let httpResponse = response.httpResponse
    
    if httpResponse.statusCode == 200 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .object(try JSONDecoder().decode(Operations.GetMediaProvidersResponseBody.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 400 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .badRequest(try JSONDecoder().decode(Operations.GetMediaProvidersBadRequest.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 401 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .unauthorized(try JSONDecoder().decode(Operations.GetMediaProvidersUnauthorized.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    }

    return .empty
}

private func handleGetServerListResponse(response: Client.APIResponse) throws -> Operations.GetServerListResponse {
    let httpResponse = response.httpResponse
    
    if httpResponse.statusCode == 200 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .object(try JSONDecoder().decode(Operations.GetServerListResponseBody.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 400 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .badRequest(try JSONDecoder().decode(Operations.GetServerListBadRequest.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    } else if httpResponse.statusCode == 401 { 
        if httpResponse.contentType.matchContentType(pattern: "application/json"), let data = response.data {
            do {
                return .unauthorized(try JSONDecoder().decode(Operations.GetServerListUnauthorized.self, from: data))
            } catch {
                throw ResponseHandlerError.failedToDecodeJSON(error)
            }
        }
    }

    return .empty
}