diff options
Diffstat (limited to 'Sources/LichessClient/Generated/Client.swift')
| -rw-r--r-- | Sources/LichessClient/Generated/Client.swift | 14299 |
1 files changed, 14299 insertions, 0 deletions
diff --git a/Sources/LichessClient/Generated/Client.swift b/Sources/LichessClient/Generated/Client.swift new file mode 100644 index 0000000..520c266 --- /dev/null +++ b/Sources/LichessClient/Generated/Client.swift @@ -0,0 +1,14299 @@ +// Generated by swift-openapi-generator, do not modify. +@_spi(Generated) import OpenAPIRuntime +#if os(Linux) +@preconcurrency import struct Foundation.URL +@preconcurrency import struct Foundation.Data +@preconcurrency import struct Foundation.Date +#else +import struct Foundation.URL +import struct Foundation.Data +import struct Foundation.Date +#endif +import HTTPTypes +/// # Introduction +/// Welcome to the reference for the Lichess API! Lichess is free/libre, +/// open-source chess server powered by volunteers and donations. +/// - Get help in the [Lichess Discord channel](https://discord.gg/lichess) +/// - API demo app with OAuth2 login and gameplay: [source](https://github.com/lichess-org/api-demo) / [demo](https://lichess-org.github.io/api-demo/) +/// - API UI app with OAuth2 login and endpoint forms: [source](https://github.com/lichess-org/api-ui) / [website](https://lichess.org/api/ui) +/// - [Contribute to this documentation on Github](https://github.com/lichess-org/api) +/// - Check out [Lichess widgets to embed in your website](https://lichess.org/developers) +/// - [Download all Lichess rated games](https://database.lichess.org/) +/// - [Download all Lichess puzzles with themes, ratings and votes](https://database.lichess.org/#puzzles) +/// - [Download all evaluated positions](https://database.lichess.org/#evals) +/// +/// ## Endpoint +/// All requests go to `https://lichess.org` (unless otherwise specified). +/// +/// ## Clients +/// - [Python general API](https://github.com/lichess-org/berserk) +/// - [MicroPython general API](https://github.com/mkomon/uberserk) +/// - [Python general API - async](https://pypi.org/project/async-lichess-sdk) +/// - [Python Lichess Bot](https://github.com/lichess-bot-devs/lichess-bot) +/// - [Python Board API for Certabo](https://github.com/haklein/certabo-lichess) +/// - [Java general API](https://github.com/tors42/chariot) +/// - [JavaScript & TypeScript general API](https://github.com/devjiwonchoi/equine) +/// +/// ## Rate limiting +/// All requests are rate limited using various strategies, +/// to ensure the API remains responsive for everyone. +/// Only make one request at a time. +/// If you receive an HTTP response with a [429 status](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes#429), +/// please wait a full minute before resuming API usage. +/// +/// ## Streaming with ND-JSON +/// Some API endpoints stream their responses as [Newline Delimited JSON a.k.a. **nd-json**](https://github.com/ndjson/ndjson-spec), with one JSON object per line. +/// +/// Here's a [JavaScript utility function](https://gist.github.com/ornicar/a097406810939cf7be1df8ea30e94f3e) to help reading NDJSON streamed responses. +/// +/// ## Authentication +/// ### Which authentication method is right for me? +/// [Read about the Lichess API authentication methods and code examples](https://github.com/lichess-org/api/blob/master/example/README.md) +/// +/// ### Personal Access Token +/// Personal API access tokens allow you to quickly interact with Lichess API without going through an OAuth flow. +/// - [Generate a personal access token](https://lichess.org/account/oauth/token) +/// - `curl https://lichess.org/api/account -H "Authorization: Bearer {token}"` +/// - [NodeJS example](https://github.com/lichess-org/api/tree/master/example/oauth-personal-token) +/// +/// ### Authorization Code Flow with PKCE +/// The authorization code flow with PKCE allows your users to **login with Lichess**. +/// Lichess supports unregistered and public clients (no client authentication, choose any unique client id). +/// The only accepted code challenge method is `S256`. +/// Access tokens are long-lived (expect one year), unless they are revoked. +/// Refresh tokens are not supported. +/// +/// See the [documentation for the OAuth endpoints](#tag/OAuth) or +/// the [PKCE RFC](https://datatracker.ietf.org/doc/html/rfc7636#section-4) for a precise protocol description. +/// +/// - [Demo app](https://lichess-org.github.io/api-demo/) +/// - [Minimal client-side example](https://github.com/lichess-org/api/tree/master/example/oauth-app) +/// - [Flask/Python example](https://github.com/lakinwecker/lichess-oauth-flask) +/// - [Java example](https://github.com/tors42/lichess-oauth-pkce-app) +/// - [NodeJS Passport strategy to login with Lichess OAuth2](https://www.npmjs.com/package/passport-lichess) +/// +/// #### Real life examples +/// - [PyChess](https://github.com/gbtami/pychess-variants) ([source code](https://github.com/gbtami/pychess-variants)) +/// - [Lichess4545](https://www.lichess4545.com/) ([source code](https://github.com/cyanfish/heltour)) +/// - [English Chess Federation](https://ecf.octoknight.com/) +/// - [Rotherham Online Chess](https://rotherhamonlinechess.azurewebsites.net/tournaments) +/// +/// ### Token format +/// Access tokens and authorization codes match `^[A-Za-z0-9_]+$`. +/// The length of tokens can be increased without notice. Make sure your application can handle at least 512 characters. +/// By convention tokens have a recognizable prefix, but do not rely on this. +/// +internal 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. + internal init( + serverURL: Foundation.URL, + configuration: Configuration = .init(), + transport: any ClientTransport, + middlewares: [any ClientMiddleware] = [] + ) { + self.client = .init( + serverURL: serverURL, + configuration: configuration, + transport: transport, + middlewares: middlewares + ) + } + private var converter: Converter { + client.converter + } + /// Get real-time users status + /// + /// Read the `online`, `playing` and `streaming` flags of several users. + /// This API is very fast and cheap on lichess side. + /// So you can call it quite often (like once every 5 seconds). + /// Use it to track players and know when they're connected on lichess and playing games. + /// + /// + /// - Remark: HTTP `GET /api/users/status`. + /// - Remark: Generated from `#/paths//api/users/status/get(apiUsersStatus)`. + internal func apiUsersStatus(_ input: Operations.apiUsersStatus.Input) async throws -> Operations.apiUsersStatus.Output { + try await client.send( + input: input, + forOperation: Operations.apiUsersStatus.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/users/status", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "ids", + value: input.query.ids + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "withGameIds", + value: input.query.withGameIds + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiUsersStatus.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiUsersStatus.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Operations.apiUsersStatus.Output.Ok.Body.jsonPayload.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get all top 10 + /// + /// Get the top 10 players for each speed and variant. + /// See <https://lichess.org/player>. + /// + /// + /// - Remark: HTTP `GET /api/player`. + /// - Remark: Generated from `#/paths//api/player/get(player)`. + internal func player(_ input: Operations.player.Input) async throws -> Operations.player.Output { + try await client.send( + input: input, + forOperation: Operations.player.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/player", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.player.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.player.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Top10s.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get one leaderboard + /// + /// Get the leaderboard for a single speed or variant (a.k.a. `perfType`). + /// There is no leaderboard for correspondence or puzzles. + /// See <https://lichess.org/player/top/200/bullet>. + /// + /// + /// - Remark: HTTP `GET /api/player/top/{nb}/{perfType}`. + /// - Remark: Generated from `#/paths//api/player/top/{nb}/{perfType}/get(playerTopNbPerfType)`. + internal func playerTopNbPerfType(_ input: Operations.playerTopNbPerfType.Input) async throws -> Operations.playerTopNbPerfType.Output { + try await client.send( + input: input, + forOperation: Operations.playerTopNbPerfType.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/player/top/{}/{}", + parameters: [ + input.path.nb, + input.path.perfType + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.playerTopNbPerfType.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.playerTopNbPerfType.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/vnd.lichess.v3+json" + ] + ) + switch chosenContentType { + case "application/vnd.lichess.v3+json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Leaderboard.self, + from: responseBody, + transforming: { value in + .application_vnd_period_lichess_period_v3_plus_json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get user public data + /// + /// Read public data of a user. + /// + /// + /// - Remark: HTTP `GET /api/user/{username}`. + /// - Remark: Generated from `#/paths//api/user/{username}/get(apiUser)`. + internal func apiUser(_ input: Operations.apiUser.Input) async throws -> Operations.apiUser.Output { + try await client.send( + input: input, + forOperation: Operations.apiUser.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/user/{}", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "trophies", + value: input.query.trophies + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiUser.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiUser.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.UserExtended.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get rating history of a user + /// + /// Read rating history of a user, for all perf types. + /// There is at most one entry per day. + /// Format of an entry is `[year, month, day, rating]`. + /// `month` starts at zero (January). + /// + /// + /// - Remark: HTTP `GET /api/user/{username}/rating-history`. + /// - Remark: Generated from `#/paths//api/user/{username}/rating-history/get(apiUserRatingHistory)`. + internal func apiUserRatingHistory(_ input: Operations.apiUserRatingHistory.Input) async throws -> Operations.apiUserRatingHistory.Output { + try await client.send( + input: input, + forOperation: Operations.apiUserRatingHistory.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/user/{}/rating-history", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiUserRatingHistory.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiUserRatingHistory.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.RatingHistory.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get performance statistics of a user + /// + /// Read performance statistics of a user, for a single performance. + /// Similar to the [performance pages on the website](https://lichess.org/@/thibault/perf/bullet). + /// + /// + /// - Remark: HTTP `GET /api/user/{username}/perf/{perf}`. + /// - Remark: Generated from `#/paths//api/user/{username}/perf/{perf}/get(apiUserPerf)`. + internal func apiUserPerf(_ input: Operations.apiUserPerf.Input) async throws -> Operations.apiUserPerf.Output { + try await client.send( + input: input, + forOperation: Operations.apiUserPerf.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/user/{}/perf/{}", + parameters: [ + input.path.username, + input.path.perf + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiUserPerf.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiUserPerf.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.PerfStat.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get user activity + /// + /// Read data to generate the activity feed of a user. + /// + /// + /// - Remark: HTTP `GET /api/user/{username}/activity`. + /// - Remark: Generated from `#/paths//api/user/{username}/activity/get(apiUserActivity)`. + internal func apiUserActivity(_ input: Operations.apiUserActivity.Input) async throws -> Operations.apiUserActivity.Output { + try await client.send( + input: input, + forOperation: Operations.apiUserActivity.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/user/{}/activity", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiUserActivity.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiUserActivity.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + OpenAPIRuntime.OpenAPIValueContainer.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get the daily puzzle + /// + /// Get the daily Lichess puzzle in JSON format. + /// Alternatively, you can [post it in your slack workspace](https://lichess.org/daily-puzzle-slack). + /// + /// + /// - Remark: HTTP `GET /api/puzzle/daily`. + /// - Remark: Generated from `#/paths//api/puzzle/daily/get(apiPuzzleDaily)`. + internal func apiPuzzleDaily(_ input: Operations.apiPuzzleDaily.Input) async throws -> Operations.apiPuzzleDaily.Output { + try await client.send( + input: input, + forOperation: Operations.apiPuzzleDaily.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/puzzle/daily", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiPuzzleDaily.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiPuzzleDaily.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.PuzzleAndGame.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get a puzzle by its ID + /// + /// Get a single Lichess puzzle in JSON format. + /// + /// - Remark: HTTP `GET /api/puzzle/{id}`. + /// - Remark: Generated from `#/paths//api/puzzle/{id}/get(apiPuzzleId)`. + internal func apiPuzzleId(_ input: Operations.apiPuzzleId.Input) async throws -> Operations.apiPuzzleId.Output { + try await client.send( + input: input, + forOperation: Operations.apiPuzzleId.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/puzzle/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiPuzzleId.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiPuzzleId.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.PuzzleAndGame.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get your puzzle activity + /// + /// Download your puzzle activity in [ndjson](#section/Introduction/Streaming-with-ND-JSON) format. + /// Puzzle activity is sorted by reverse chronological order (most recent first) + /// We recommend streaming the response, for it can be very long. + /// + /// + /// - Remark: HTTP `GET /api/puzzle/activity`. + /// - Remark: Generated from `#/paths//api/puzzle/activity/get(apiPuzzleActivity)`. + internal func apiPuzzleActivity(_ input: Operations.apiPuzzleActivity.Input) async throws -> Operations.apiPuzzleActivity.Output { + try await client.send( + input: input, + forOperation: Operations.apiPuzzleActivity.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/puzzle/activity", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "max", + value: input.query.max + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "before", + value: input.query.before + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiPuzzleActivity.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiPuzzleActivity.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get your puzzle dashboard + /// + /// Download your [puzzle dashboard](https://lichess.org/training/dashboard/30/dashboard) as JSON. + /// Also includes all puzzle themes played, with aggregated results. + /// Allows re-creating the [improvement/strengths](https://lichess.org/training/dashboard/30/improvementAreas) interfaces. + /// + /// + /// - Remark: HTTP `GET /api/puzzle/dashboard/{days}`. + /// - Remark: Generated from `#/paths//api/puzzle/dashboard/{days}/get(apiPuzzleDashboard)`. + internal func apiPuzzleDashboard(_ input: Operations.apiPuzzleDashboard.Input) async throws -> Operations.apiPuzzleDashboard.Output { + try await client.send( + input: input, + forOperation: Operations.apiPuzzleDashboard.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/puzzle/dashboard/{}", + parameters: [ + input.path.days + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiPuzzleDashboard.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiPuzzleDashboard.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.PuzzleDashboardJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get the storm dashboard of a player + /// + /// Download the [storm dashboard](https://lichess.org/storm/dashboard/mrbasso) of any player as JSON. + /// Contains the aggregated highscores, and the history of storm runs aggregated by days. + /// Use `?days=0` if you only care about the highscores. + /// + /// + /// - Remark: HTTP `GET /api/storm/dashboard/{username}`. + /// - Remark: Generated from `#/paths//api/storm/dashboard/{username}/get(apiStormDashboard)`. + internal func apiStormDashboard(_ input: Operations.apiStormDashboard.Input) async throws -> Operations.apiStormDashboard.Output { + try await client.send( + input: input, + forOperation: Operations.apiStormDashboard.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/storm/dashboard/{}", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "days", + value: input.query.days + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiStormDashboard.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiStormDashboard.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.StormDashboardJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Create and join a puzzle race + /// + /// Create a new private [puzzle race](https://lichess.org/racer). + /// The Lichess user who creates the race must join the race page, + /// and manually start the race when enough players have joined. + /// - <https://lichess.org/racer> + /// + /// + /// - Remark: HTTP `POST /api/racer`. + /// - Remark: Generated from `#/paths//api/racer/post(racerPost)`. + internal func racerPost(_ input: Operations.racerPost.Input) async throws -> Operations.racerPost.Output { + try await client.send( + input: input, + forOperation: Operations.racerPost.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/racer", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.racerPost.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.racerPost.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.PuzzleRaceJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get users by ID + /// + /// Get up to 300 users by their IDs. Users are returned in the same order as the IDs. + /// The method is `POST` to allow a longer list of IDs to be sent in the request body. + /// Please do not try to download all the Lichess users with this endpoint, or any other endpoint. + /// An API is not a way to fully export a website. We do not provide a full download of the Lichess users. + /// This endpoint is limited to 8,000 users every 10 minutes, and 120,000 every day. + /// + /// + /// - Remark: HTTP `POST /api/users`. + /// - Remark: Generated from `#/paths//api/users/post(apiUsers)`. + internal func apiUsers(_ input: Operations.apiUsers.Input) async throws -> Operations.apiUsers.Output { + try await client.send( + input: input, + forOperation: Operations.apiUsers.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/users", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .plainText(value): + body = try converter.setRequiredRequestBodyAsBinary( + value, + headerFields: &request.headerFields, + contentType: "text/plain" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiUsers.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiUsers.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + [Components.Schemas.User].self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get my profile + /// + /// Public information about the logged in user. + /// + /// + /// - Remark: HTTP `GET /api/account`. + /// - Remark: Generated from `#/paths//api/account/get(accountMe)`. + internal func accountMe(_ input: Operations.accountMe.Input) async throws -> Operations.accountMe.Output { + try await client.send( + input: input, + forOperation: Operations.accountMe.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/account", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.accountMe.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.accountMe.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.UserExtended.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get my email address + /// + /// Read the email address of the logged in user. + /// + /// + /// - Remark: HTTP `GET /api/account/email`. + /// - Remark: Generated from `#/paths//api/account/email/get(accountEmail)`. + internal func accountEmail(_ input: Operations.accountEmail.Input) async throws -> Operations.accountEmail.Output { + try await client.send( + input: input, + forOperation: Operations.accountEmail.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/account/email", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.accountEmail.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.accountEmail.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Operations.accountEmail.Output.Ok.Body.jsonPayload.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get my preferences + /// + /// Read the preferences of the logged in user. + /// - <https://lichess.org/account/preferences/game-display> + /// - <https://github.com/ornicar/lila/blob/master/modules/pref/src/main/Pref.scala> + /// + /// + /// - Remark: HTTP `GET /api/account/preferences`. + /// - Remark: Generated from `#/paths//api/account/preferences/get(account)`. + internal func account(_ input: Operations.account.Input) async throws -> Operations.account.Output { + try await client.send( + input: input, + forOperation: Operations.account.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/account/preferences", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.account.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.account.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Operations.account.Output.Ok.Body.jsonPayload.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get my kid mode status + /// + /// Read the kid mode status of the logged in user. + /// - <https://lichess.org/account/kid> + /// + /// + /// - Remark: HTTP `GET /api/account/kid`. + /// - Remark: Generated from `#/paths//api/account/kid/get(accountKid)`. + internal func accountKid(_ input: Operations.accountKid.Input) async throws -> Operations.accountKid.Output { + try await client.send( + input: input, + forOperation: Operations.accountKid.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/account/kid", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.accountKid.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.accountKid.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Operations.accountKid.Output.Ok.Body.jsonPayload.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Set my kid mode status + /// + /// Set the kid mode status of the logged in user. + /// - <https://lichess.org/account/kid> + /// + /// + /// - Remark: HTTP `POST /api/account/kid`. + /// - Remark: Generated from `#/paths//api/account/kid/post(accountKidPost)`. + internal func accountKidPost(_ input: Operations.accountKidPost.Input) async throws -> Operations.accountKidPost.Output { + try await client.send( + input: input, + forOperation: Operations.accountKidPost.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/account/kid", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "v", + value: input.query.v + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.accountKidPost.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.accountKidPost.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get my timeline + /// + /// Get the timeline events of the logged in user. + /// + /// + /// - Remark: HTTP `GET /api/timeline`. + /// - Remark: Generated from `#/paths//api/timeline/get(timeline)`. + internal func timeline(_ input: Operations.timeline.Input) async throws -> Operations.timeline.Output { + try await client.send( + input: input, + forOperation: Operations.timeline.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/timeline", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "since", + value: input.query.since + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "nb", + value: input.query.nb + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.timeline.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.timeline.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Timeline.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export one game + /// + /// Download one game in either PGN or JSON format. + /// Ongoing games are delayed by a few seconds ranging from 3 to 60 depending on the time control, as to prevent cheat bots from using this API. + /// + /// + /// - Remark: HTTP `GET /game/export/{gameId}`. + /// - Remark: Generated from `#/paths//game/export/{gameId}/get(gamePgn)`. + internal func gamePgn(_ input: Operations.gamePgn.Input) async throws -> Operations.gamePgn.Output { + try await client.send( + input: input, + forOperation: Operations.gamePgn.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/game/export/{}", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "moves", + value: input.query.moves + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "pgnInJson", + value: input.query.pgnInJson + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "tags", + value: input.query.tags + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "clocks", + value: input.query.clocks + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "evals", + value: input.query.evals + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "accuracy", + value: input.query.accuracy + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "opening", + value: input.query.opening + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "division", + value: input.query.division + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "literate", + value: input.query.literate + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "players", + value: input.query.players + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.gamePgn.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.gamePgn.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn", + "application/json" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.GameJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export ongoing game of a user + /// + /// Download the ongoing game, or the last game played, of a user. + /// Available in either PGN or JSON format. + /// Ongoing games are delayed by a few seconds ranging from 3 to 60 depending on the time control, as to prevent cheat bots from using this API. + /// + /// + /// - Remark: HTTP `GET /api/user/{username}/current-game`. + /// - Remark: Generated from `#/paths//api/user/{username}/current-game/get(apiUserCurrentGame)`. + internal func apiUserCurrentGame(_ input: Operations.apiUserCurrentGame.Input) async throws -> Operations.apiUserCurrentGame.Output { + try await client.send( + input: input, + forOperation: Operations.apiUserCurrentGame.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/user/{}/current-game", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "moves", + value: input.query.moves + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "pgnInJson", + value: input.query.pgnInJson + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "tags", + value: input.query.tags + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "clocks", + value: input.query.clocks + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "evals", + value: input.query.evals + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "accuracy", + value: input.query.accuracy + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "opening", + value: input.query.opening + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "division", + value: input.query.division + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "literate", + value: input.query.literate + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "players", + value: input.query.players + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiUserCurrentGame.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiUserCurrentGame.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn", + "application/json" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.GameJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export games of a user + /// + /// Download all games of any user in PGN or [ndjson](#section/Introduction/Streaming-with-ND-JSON) format. + /// Games are sorted by reverse chronological order (most recent first). + /// We recommend streaming the response, for it can be very long. + /// <https://lichess.org/@/german11> for instance has more than 500,000 games. + /// The game stream is throttled, depending on who is making the request: + /// - Anonymous request: 20 games per second + /// - [OAuth2 authenticated](#section/Introduction/Authentication) request: 30 games per second + /// - Authenticated, downloading your own games: 60 games per second + /// + /// + /// - Remark: HTTP `GET /api/games/user/{username}`. + /// - Remark: Generated from `#/paths//api/games/user/{username}/get(apiGamesUser)`. + internal func apiGamesUser(_ input: Operations.apiGamesUser.Input) async throws -> Operations.apiGamesUser.Output { + try await client.send( + input: input, + forOperation: Operations.apiGamesUser.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/games/user/{}", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "since", + value: input.query.since + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "until", + value: input.query.until + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "max", + value: input.query.max + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "vs", + value: input.query.vs + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "rated", + value: input.query.rated + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "perfType", + value: input.query.perfType + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "color", + value: input.query.color + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "analysed", + value: input.query.analysed + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "moves", + value: input.query.moves + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "pgnInJson", + value: input.query.pgnInJson + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "tags", + value: input.query.tags + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "clocks", + value: input.query.clocks + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "evals", + value: input.query.evals + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "accuracy", + value: input.query.accuracy + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "opening", + value: input.query.opening + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "division", + value: input.query.division + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "ongoing", + value: input.query.ongoing + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "finished", + value: input.query.finished + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "literate", + value: input.query.literate + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "lastFen", + value: input.query.lastFen + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "players", + value: input.query.players + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "sort", + value: input.query.sort + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiGamesUser.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiGamesUser.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn", + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export games by IDs + /// + /// Download games by IDs in PGN or [ndjson](#section/Introduction/Streaming-with-ND-JSON) format, depending on the request `Accept` header. + /// Games are sorted by reverse chronological order (most recent first) + /// The method is `POST` so a longer list of IDs can be sent in the request body. + /// 300 IDs can be submitted. + /// Ongoing games are delayed by a few seconds ranging from 3 to 60 depending on the time control, as to prevent cheat bots from using this API. + /// + /// + /// - Remark: HTTP `POST /api/games/export/_ids`. + /// - Remark: Generated from `#/paths//api/games/export/_ids/post(gamesExportIds)`. + internal func gamesExportIds(_ input: Operations.gamesExportIds.Input) async throws -> Operations.gamesExportIds.Output { + try await client.send( + input: input, + forOperation: Operations.gamesExportIds.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/games/export/_ids", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "moves", + value: input.query.moves + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "pgnInJson", + value: input.query.pgnInJson + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "tags", + value: input.query.tags + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "clocks", + value: input.query.clocks + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "evals", + value: input.query.evals + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "accuracy", + value: input.query.accuracy + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "opening", + value: input.query.opening + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "division", + value: input.query.division + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "literate", + value: input.query.literate + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "players", + value: input.query.players + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .plainText(value): + body = try converter.setRequiredRequestBodyAsBinary( + value, + headerFields: &request.headerFields, + contentType: "text/plain" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.gamesExportIds.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.gamesExportIds.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn", + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Stream games of users + /// + /// Stream the games played between a list of users, in real time. + /// Only games where **both players** are part of the list are included. + /// The stream emits an event each time a game is started or finished. + /// To also get all current ongoing games at the beginning of the stream, use the `withCurrentGames` flag. + /// Games are streamed as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// Maximum number of users: 300. + /// The method is `POST` so a longer list of IDs can be sent in the request body. + /// + /// + /// - Remark: HTTP `POST /api/stream/games-by-users`. + /// - Remark: Generated from `#/paths//api/stream/games-by-users/post(gamesByUsers)`. + internal func gamesByUsers(_ input: Operations.gamesByUsers.Input) async throws -> Operations.gamesByUsers.Output { + try await client.send( + input: input, + forOperation: Operations.gamesByUsers.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/stream/games-by-users", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "withCurrentGames", + value: input.query.withCurrentGames + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .plainText(value): + body = try converter.setRequiredRequestBodyAsBinary( + value, + headerFields: &request.headerFields, + contentType: "text/plain" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.gamesByUsers.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.gamesByUsers.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Stream games by IDs + /// + /// Creates a stream of games from an arbitrary streamId, and a list of game IDs. + /// The stream first outputs the games that already exists, then emits an event each time a game is started or finished. + /// Games are streamed as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// Maximum number of games: 500 for anonymous requests, or 1000 for [OAuth2 authenticated](#section/Introduction/Authentication) requests. + /// While the stream is open, it is possible to [add new game IDs to watch](#operation/gamesByIdsAdd). + /// + /// + /// - Remark: HTTP `POST /api/stream/games/{streamId}`. + /// - Remark: Generated from `#/paths//api/stream/games/{streamId}/post(gamesByIds)`. + internal func gamesByIds(_ input: Operations.gamesByIds.Input) async throws -> Operations.gamesByIds.Output { + try await client.send( + input: input, + forOperation: Operations.gamesByIds.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/stream/games/{}", + parameters: [ + input.path.streamId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .plainText(value): + body = try converter.setRequiredRequestBodyAsBinary( + value, + headerFields: &request.headerFields, + contentType: "text/plain" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.gamesByIds.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.gamesByIds.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Add game IDs to stream + /// + /// Add new game IDs for [an existing stream](#operation/gamesByIds) to watch. + /// The stream will immediately outputs the games that already exists, then emit an event each time a game is started or finished. + /// + /// + /// - Remark: HTTP `POST /api/stream/games/{streamId}/add`. + /// - Remark: Generated from `#/paths//api/stream/games/{streamId}/add/post(gamesByIdsAdd)`. + internal func gamesByIdsAdd(_ input: Operations.gamesByIdsAdd.Input) async throws -> Operations.gamesByIdsAdd.Output { + try await client.send( + input: input, + forOperation: Operations.gamesByIdsAdd.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/stream/games/{}/add", + parameters: [ + input.path.streamId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .plainText(value): + body = try converter.setRequiredRequestBodyAsBinary( + value, + headerFields: &request.headerFields, + contentType: "text/plain" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.gamesByIdsAdd.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.gamesByIdsAdd.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get my ongoing games + /// + /// Get the ongoing games of the current user. + /// Real-time and correspondence games are included. + /// The most urgent games are listed first. + /// + /// + /// - Remark: HTTP `GET /api/account/playing`. + /// - Remark: Generated from `#/paths//api/account/playing/get(apiAccountPlaying)`. + internal func apiAccountPlaying(_ input: Operations.apiAccountPlaying.Input) async throws -> Operations.apiAccountPlaying.Output { + try await client.send( + input: input, + forOperation: Operations.apiAccountPlaying.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/account/playing", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "nb", + value: input.query.nb + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiAccountPlaying.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiAccountPlaying.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + OpenAPIRuntime.OpenAPIValueContainer.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Stream moves of a game + /// + /// Stream positions and moves of any ongoing game, in [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// A description of the game is sent as a first message. + /// Then a message is sent each time a move is played. + /// Finally a description of the game is sent when it finishes, and the stream is closed. + /// Ongoing games are delayed by a few seconds ranging from 3 to 60 depending on the time control, as to prevent cheat bots from using this API. + /// No more than 8 game streams can be opened at the same time from the same IP address. + /// + /// + /// - Remark: HTTP `GET /api/stream/game/{id}`. + /// - Remark: Generated from `#/paths//api/stream/game/{id}/get(streamGame)`. + internal func streamGame(_ input: Operations.streamGame.Input) async throws -> Operations.streamGame.Output { + try await client.send( + input: input, + forOperation: Operations.streamGame.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/stream/game/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.streamGame.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Import one game + /// + /// Import a game from PGN. See <https://lichess.org/paste>. + /// Rate limiting: 200 games per hour for OAuth requests, 100 games per hour for anonymous requests. + /// To broadcast ongoing games, consider [pushing to a broadcast instead](#operation/broadcastPush). + /// To analyse a position or a line, just construct an analysis board URL: + /// [https://lichess.org/analysis/pgn/e4_e5_Nf3_Nc6_Bc4_Bc5_Bxf7+](https://lichess.org/analysis/pgn/e4_e5_Nf3_Nc6_Bc4_Bc5_Bxf7+) + /// + /// + /// - Remark: HTTP `POST /api/import`. + /// - Remark: Generated from `#/paths//api/import/post(gameImport)`. + internal func gameImport(_ input: Operations.gameImport.Input) async throws -> Operations.gameImport.Output { + try await client.send( + input: input, + forOperation: Operations.gameImport.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/import", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.gameImport.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.gameImport.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + OpenAPIRuntime.OpenAPIValueContainer.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export your imported games + /// + /// Download all games imported by you. Games are exported in PGN format. + /// + /// - Remark: HTTP `GET /api/games/export/imports`. + /// - Remark: Generated from `#/paths//api/games/export/imports/get(apiImportedGamesUser)`. + internal func apiImportedGamesUser(_ input: Operations.apiImportedGamesUser.Input) async throws -> Operations.apiImportedGamesUser.Output { + try await client.send( + input: input, + forOperation: Operations.apiImportedGamesUser.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/games/export/imports", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiImportedGamesUser.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiImportedGamesUser.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get current TV games + /// + /// Get basic info about the best games being played for each speed and variant, + /// but also computer games and bot games. + /// See [lichess.org/tv](https://lichess.org/tv). + /// + /// + /// - Remark: HTTP `GET /api/tv/channels`. + /// - Remark: Generated from `#/paths//api/tv/channels/get(tvChannels)`. + internal func tvChannels(_ input: Operations.tvChannels.Input) async throws -> Operations.tvChannels.Output { + try await client.send( + input: input, + forOperation: Operations.tvChannels.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tv/channels", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.tvChannels.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.tvChannels.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + OpenAPIRuntime.OpenAPIValueContainer.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Stream current TV game + /// + /// Stream positions and moves of the current [TV game](https://lichess.org/tv) in [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// A summary of the game is sent as a first message, and when the featured game changes. + /// Try it with `curl https://lichess.org/api/tv/feed`. + /// + /// + /// - Remark: HTTP `GET /api/tv/feed`. + /// - Remark: Generated from `#/paths//api/tv/feed/get(tvFeed)`. + internal func tvFeed(_ input: Operations.tvFeed.Input) async throws -> Operations.tvFeed.Output { + try await client.send( + input: input, + forOperation: Operations.tvFeed.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tv/feed", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.tvFeed.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Stream current TV game of a TV channel + /// + /// Stream positions and moves of the current [TV game](https://lichess.org/tv) of a TV channel in [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// A summary of the game is sent as a first message, and when the featured game changes. + /// Try it with `curl https://lichess.org/api/tv/rapid/feed`. + /// + /// + /// - Remark: HTTP `GET /api/tv/{channel}/feed`. + /// - Remark: Generated from `#/paths//api/tv/{channel}/feed/get(tvChannelFeed)`. + internal func tvChannelFeed(_ input: Operations.tvChannelFeed.Input) async throws -> Operations.tvChannelFeed.Output { + try await client.send( + input: input, + forOperation: Operations.tvChannelFeed.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tv/{}/feed", + parameters: [ + input.path.channel + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.tvChannelFeed.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get best ongoing games of a TV channel + /// + /// Get a list of ongoing games for a given TV channel. Similar to [lichess.org/games](https://lichess.org/games). + /// Available in PGN or [ndjson](#section/Introduction/Streaming-with-ND-JSON) format, depending on the request `Accept` header. + /// + /// + /// - Remark: HTTP `GET /api/tv/{channel}`. + /// - Remark: Generated from `#/paths//api/tv/{channel}/get(tvChannelGames)`. + internal func tvChannelGames(_ input: Operations.tvChannelGames.Input) async throws -> Operations.tvChannelGames.Output { + try await client.send( + input: input, + forOperation: Operations.tvChannelGames.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tv/{}", + parameters: [ + input.path.channel + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "nb", + value: input.query.nb + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "moves", + value: input.query.moves + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "pgnInJson", + value: input.query.pgnInJson + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "tags", + value: input.query.tags + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "clocks", + value: input.query.clocks + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "opening", + value: input.query.opening + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.tvChannelGames.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn", + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get current tournaments + /// + /// Get recently finished, ongoing, and upcoming tournaments. + /// This API is used to display the [Lichess tournament schedule](https://lichess.org/tournament). + /// + /// + /// - Remark: HTTP `GET /api/tournament`. + /// - Remark: Generated from `#/paths//api/tournament/get(apiTournament)`. + internal func apiTournament(_ input: Operations.apiTournament.Input) async throws -> Operations.apiTournament.Output { + try await client.send( + input: input, + forOperation: Operations.apiTournament.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tournament", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiTournament.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournament.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.ArenaTournaments.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Create a new Arena tournament + /// + /// Create a public or private Arena tournament. + /// This endpoint mirrors the form on <https://lichess.org/tournament/new>. + /// You can create up to 12 public tournaments per day, or 24 private tournaments. + /// A team battle can be created by specifying the `teamBattleByTeam` argument. + /// Additional restrictions: + /// - clockTime + clockIncrement > 0 + /// - 15s and 0+1 variant tournaments cannot be rated + /// - Clock time in comparison to tournament length must be reasonable: 3 <= (minutes * 60) / (96 * clockTime + 48 * clockIncrement + 15) <= 150 + /// + /// + /// - Remark: HTTP `POST /api/tournament`. + /// - Remark: Generated from `#/paths//api/tournament/post(apiTournamentPost)`. + internal func apiTournamentPost(_ input: Operations.apiTournamentPost.Input) async throws -> Operations.apiTournamentPost.Output { + try await client.send( + input: input, + forOperation: Operations.apiTournamentPost.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tournament", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiTournamentPost.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentPost.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.ArenaTournamentVariantIsKey.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentPost.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get info about an Arena tournament + /// + /// Get detailed info about recently finished, current, or upcoming tournament's duels, player standings, and other info. + /// + /// + /// - Remark: HTTP `GET /api/tournament/{id}`. + /// - Remark: Generated from `#/paths//api/tournament/{id}/get(tournament)`. + internal func tournament(_ input: Operations.tournament.Input) async throws -> Operations.tournament.Output { + try await client.send( + input: input, + forOperation: Operations.tournament.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tournament/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "page", + value: input.query.page + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.tournament.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.tournament.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.ArenaTournamentVariantIsKey.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Update an Arena tournament + /// + /// Update an Arena tournament. + /// Be mindful not to make important changes to ongoing tournaments. + /// Can be used to update a team battle. + /// Additional restrictions: + /// - clockTime + clockIncrement > 0 + /// - 15s and 0+1 variant tournaments cannot be rated + /// - Clock time in comparison to tournament length must be reasonable: 3 <= (minutes * 60) / (96 * clockTime + 48 * clockIncrement + 15) <= 150 + /// + /// + /// - Remark: HTTP `POST /api/tournament/{id}`. + /// - Remark: Generated from `#/paths//api/tournament/{id}/post(apiTournamentUpdate)`. + internal func apiTournamentUpdate(_ input: Operations.apiTournamentUpdate.Input) async throws -> Operations.apiTournamentUpdate.Output { + try await client.send( + input: input, + forOperation: Operations.apiTournamentUpdate.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tournament/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiTournamentUpdate.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentUpdate.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.ArenaTournamentVariantIsKey.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentUpdate.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Join an Arena tournament + /// + /// Join an Arena tournament, possibly with a password and/or a team. + /// Also unpauses if you had previously [paused](#operation/apiTournamentWithdraw) the tournament. + /// + /// + /// - Remark: HTTP `POST /api/tournament/{id}/join`. + /// - Remark: Generated from `#/paths//api/tournament/{id}/join/post(apiTournamentJoin)`. + internal func apiTournamentJoin(_ input: Operations.apiTournamentJoin.Input) async throws -> Operations.apiTournamentJoin.Output { + try await client.send( + input: input, + forOperation: Operations.apiTournamentJoin.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tournament/{}/join", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiTournamentJoin.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentJoin.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentJoin.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Pause or leave an Arena tournament + /// + /// Leave a future Arena tournament, or take a break on an ongoing Arena tournament. + /// It's possible to join again later. Points and streaks are preserved. + /// + /// + /// - Remark: HTTP `POST /api/tournament/{id}/withdraw`. + /// - Remark: Generated from `#/paths//api/tournament/{id}/withdraw/post(apiTournamentWithdraw)`. + internal func apiTournamentWithdraw(_ input: Operations.apiTournamentWithdraw.Input) async throws -> Operations.apiTournamentWithdraw.Output { + try await client.send( + input: input, + forOperation: Operations.apiTournamentWithdraw.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tournament/{}/withdraw", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiTournamentWithdraw.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentWithdraw.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentWithdraw.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Terminate an Arena tournament + /// + /// Terminate an Arena tournament + /// + /// + /// - Remark: HTTP `POST /api/tournament/{id}/terminate`. + /// - Remark: Generated from `#/paths//api/tournament/{id}/terminate/post(apiTournamentTerminate)`. + internal func apiTournamentTerminate(_ input: Operations.apiTournamentTerminate.Input) async throws -> Operations.apiTournamentTerminate.Output { + try await client.send( + input: input, + forOperation: Operations.apiTournamentTerminate.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tournament/{}/terminate", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiTournamentTerminate.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentTerminate.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentTerminate.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Update a team battle + /// + /// Set the teams and number of leaders of a team battle. + /// To update the other attributes of a team battle, use the [tournament update endpoint](#operation/apiTournamentUpdate). + /// + /// + /// - Remark: HTTP `POST /api/tournament/team-battle/{id}`. + /// - Remark: Generated from `#/paths//api/tournament/team-battle/{id}/post(apiTournamentTeamBattlePost)`. + internal func apiTournamentTeamBattlePost(_ input: Operations.apiTournamentTeamBattlePost.Input) async throws -> Operations.apiTournamentTeamBattlePost.Output { + try await client.send( + input: input, + forOperation: Operations.apiTournamentTeamBattlePost.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tournament/team-battle/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiTournamentTeamBattlePost.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentTeamBattlePost.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.ArenaTournamentVariantIsKey.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTournamentTeamBattlePost.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export games of an Arena tournament + /// + /// Download games of a tournament in PGN or [ndjson](#section/Introduction/Streaming-with-ND-JSON) format. + /// Games are sorted by reverse chronological order (most recent first). + /// The game stream is throttled, depending on who is making the request: + /// - Anonymous request: 20 games per second + /// - [OAuth2 authenticated](#section/Introduction/Authentication) request: 30 games per second + /// + /// + /// - Remark: HTTP `GET /api/tournament/{id}/games`. + /// - Remark: Generated from `#/paths//api/tournament/{id}/games/get(gamesByTournament)`. + internal func gamesByTournament(_ input: Operations.gamesByTournament.Input) async throws -> Operations.gamesByTournament.Output { + try await client.send( + input: input, + forOperation: Operations.gamesByTournament.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tournament/{}/games", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "player", + value: input.query.player + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "moves", + value: input.query.moves + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "pgnInJson", + value: input.query.pgnInJson + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "tags", + value: input.query.tags + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "clocks", + value: input.query.clocks + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "evals", + value: input.query.evals + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "accuracy", + value: input.query.accuracy + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "opening", + value: input.query.opening + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "division", + value: input.query.division + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.gamesByTournament.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.gamesByTournament.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn", + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get results of an Arena tournament + /// + /// Players of an Arena tournament, with their score and performance, sorted by rank (best first). + /// **Players are streamed as [ndjson](#section/Introduction/Streaming-with-ND-JSON)**, i.e. one JSON object per line. + /// If called on an ongoing tournament, results can be inconsistent + /// due to ranking changes while the players are being streamed. + /// Use on finished tournaments for guaranteed consistency. + /// + /// + /// - Remark: HTTP `GET /api/tournament/{id}/results`. + /// - Remark: Generated from `#/paths//api/tournament/{id}/results/get(resultsByTournament)`. + internal func resultsByTournament(_ input: Operations.resultsByTournament.Input) async throws -> Operations.resultsByTournament.Output { + try await client.send( + input: input, + forOperation: Operations.resultsByTournament.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tournament/{}/results", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "nb", + value: input.query.nb + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "sheet", + value: input.query.sheet + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.resultsByTournament.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.resultsByTournament.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get team standing of a team battle + /// + /// Teams of a team battle tournament, with top players, sorted by rank (best first). + /// + /// + /// - Remark: HTTP `GET /api/tournament/{id}/teams`. + /// - Remark: Generated from `#/paths//api/tournament/{id}/teams/get(teamsByTournament)`. + internal func teamsByTournament(_ input: Operations.teamsByTournament.Input) async throws -> Operations.teamsByTournament.Output { + try await client.send( + input: input, + forOperation: Operations.teamsByTournament.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/tournament/{}/teams", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.teamsByTournament.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamsByTournament.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + OpenAPIRuntime.OpenAPIValueContainer.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get tournaments created by a user + /// + /// Get all tournaments created by a given user. + /// Tournaments are sorted by reverse chronological order of start date (last starting first). + /// Tournaments are streamed as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// + /// + /// - Remark: HTTP `GET /api/user/{username}/tournament/created`. + /// - Remark: Generated from `#/paths//api/user/{username}/tournament/created/get(apiUserNameTournamentCreated)`. + internal func apiUserNameTournamentCreated(_ input: Operations.apiUserNameTournamentCreated.Input) async throws -> Operations.apiUserNameTournamentCreated.Output { + try await client.send( + input: input, + forOperation: Operations.apiUserNameTournamentCreated.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/user/{}/tournament/created", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "status", + value: input.query.status + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiUserNameTournamentCreated.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiUserNameTournamentCreated.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Create a new Swiss tournament + /// + /// Create a Swiss tournament for your team. + /// This endpoint mirrors the Swiss tournament form from your team pagee. + /// You can create up to 12 tournaments per day. + /// Additional restrictions: + /// - clock.limit + clock.increment > 0 + /// - 15s and 0+1 variant tournaments cannot be rated + /// + /// + /// - Remark: HTTP `POST /api/swiss/new/{teamId}`. + /// - Remark: Generated from `#/paths//api/swiss/new/{teamId}/post(apiSwissNew)`. + internal func apiSwissNew(_ input: Operations.apiSwissNew.Input) async throws -> Operations.apiSwissNew.Output { + try await client.send( + input: input, + forOperation: Operations.apiSwissNew.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/swiss/new/{}", + parameters: [ + input.path.teamId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiSwissNew.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissNew.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.SwissTournament.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissNew.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get info about a Swiss tournament + /// + /// Get detailed info about a Swiss tournament. + /// + /// + /// - Remark: HTTP `GET /api/swiss/{id}`. + /// - Remark: Generated from `#/paths//api/swiss/{id}/get(swiss)`. + internal func swiss(_ input: Operations.swiss.Input) async throws -> Operations.swiss.Output { + try await client.send( + input: input, + forOperation: Operations.swiss.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/swiss/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.swiss.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.swiss.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.SwissTournament.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Update a Swiss tournament + /// + /// Update a Swiss tournament. + /// Be mindful not to make important changes to ongoing tournaments. + /// Additional restrictions: + /// - clock.limit + clock.increment > 0 + /// - 15s and 0+1 variant tournaments cannot be rated + /// + /// + /// - Remark: HTTP `POST /api/swiss/{id}/edit`. + /// - Remark: Generated from `#/paths//api/swiss/{id}/edit/post(apiSwissUpdate)`. + internal func apiSwissUpdate(_ input: Operations.apiSwissUpdate.Input) async throws -> Operations.apiSwissUpdate.Output { + try await client.send( + input: input, + forOperation: Operations.apiSwissUpdate.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/swiss/{}/edit", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiSwissUpdate.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissUpdate.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.SwissTournament.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissUpdate.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + case 401: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissUpdate.Output.Unauthorized.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.SwissUnauthorisedEdit.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .unauthorized(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Manually schedule the next round + /// + /// Manually schedule the next round date and time of a Swiss tournament. + /// This sets the `roundInterval` field to `99999999`, i.e. manual scheduling. + /// All further rounds will need to be manually scheduled, unless the `roundInterval` field is changed back to automatic scheduling. + /// + /// + /// - Remark: HTTP `POST /api/swiss/{id}/schedule-next-round`. + /// - Remark: Generated from `#/paths//api/swiss/{id}/schedule-next-round/post(apiSwissScheduleNextRound)`. + internal func apiSwissScheduleNextRound(_ input: Operations.apiSwissScheduleNextRound.Input) async throws -> Operations.apiSwissScheduleNextRound.Output { + try await client.send( + input: input, + forOperation: Operations.apiSwissScheduleNextRound.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/swiss/{}/schedule-next-round", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 204: + let headers: Operations.apiSwissScheduleNextRound.Output.NoContent.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + return .noContent(.init(headers: headers)) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissScheduleNextRound.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + case 401: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissScheduleNextRound.Output.Unauthorized.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.SwissUnauthorisedEdit.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .unauthorized(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Join a Swiss tournament + /// + /// Join a Swiss tournament, possibly with a password. + /// + /// + /// - Remark: HTTP `POST /api/swiss/{id}/join`. + /// - Remark: Generated from `#/paths//api/swiss/{id}/join/post(apiSwissJoin)`. + internal func apiSwissJoin(_ input: Operations.apiSwissJoin.Input) async throws -> Operations.apiSwissJoin.Output { + try await client.send( + input: input, + forOperation: Operations.apiSwissJoin.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/swiss/{}/join", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiSwissJoin.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissJoin.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissJoin.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Pause or leave a swiss tournament + /// + /// Leave a future Swiss tournament, or take a break on an ongoing Swiss tournament. + /// It's possible to join again later. Points are preserved. + /// + /// + /// - Remark: HTTP `POST /api/swiss/{id}/withdraw`. + /// - Remark: Generated from `#/paths//api/swiss/{id}/withdraw/post(apiSwissWithdraw)`. + internal func apiSwissWithdraw(_ input: Operations.apiSwissWithdraw.Input) async throws -> Operations.apiSwissWithdraw.Output { + try await client.send( + input: input, + forOperation: Operations.apiSwissWithdraw.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/swiss/{}/withdraw", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiSwissWithdraw.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissWithdraw.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Terminate a Swiss tournament + /// + /// Terminate a Swiss tournament + /// + /// + /// - Remark: HTTP `POST /api/swiss/{id}/terminate`. + /// - Remark: Generated from `#/paths//api/swiss/{id}/terminate/post(apiSwissTerminate)`. + internal func apiSwissTerminate(_ input: Operations.apiSwissTerminate.Input) async throws -> Operations.apiSwissTerminate.Output { + try await client.send( + input: input, + forOperation: Operations.apiSwissTerminate.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/swiss/{}/terminate", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiSwissTerminate.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissTerminate.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSwissTerminate.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export TRF of a Swiss tournament + /// + /// Download a tournament in the Tournament Report File format, the FIDE standard. + /// Documentation: <https://www.fide.com/FIDE/handbook/C04Annex2_TRF16.pdf> + /// Example: <https://lichess.org/swiss/j8rtJ5GL.trf> + /// + /// + /// - Remark: HTTP `GET /swiss/{id}.trf`. + /// - Remark: Generated from `#/paths//swiss/{id}.trf/get(swissTrf)`. + internal func swissTrf(_ input: Operations.swissTrf.Input) async throws -> Operations.swissTrf.Output { + try await client.send( + input: input, + forOperation: Operations.swissTrf.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/swiss/{}.trf", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.swissTrf.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.swissTrf.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "text/plain" + ] + ) + switch chosenContentType { + case "text/plain": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .plainText(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export games of a Swiss tournament + /// + /// Download games of a swiss tournament in PGN or [ndjson](#section/Introduction/Streaming-with-ND-JSON) format. + /// Games are sorted by reverse chronological order (last round first). + /// The game stream is throttled, depending on who is making the request: + /// - Anonymous request: 20 games per second + /// - [OAuth2 authenticated](#section/Introduction/Authentication) request: 30 games per second + /// + /// + /// - Remark: HTTP `GET /api/swiss/{id}/games`. + /// - Remark: Generated from `#/paths//api/swiss/{id}/games/get(gamesBySwiss)`. + internal func gamesBySwiss(_ input: Operations.gamesBySwiss.Input) async throws -> Operations.gamesBySwiss.Output { + try await client.send( + input: input, + forOperation: Operations.gamesBySwiss.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/swiss/{}/games", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "player", + value: input.query.player + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "moves", + value: input.query.moves + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "pgnInJson", + value: input.query.pgnInJson + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "tags", + value: input.query.tags + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "clocks", + value: input.query.clocks + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "evals", + value: input.query.evals + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "accuracy", + value: input.query.accuracy + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "opening", + value: input.query.opening + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "division", + value: input.query.division + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.gamesBySwiss.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.gamesBySwiss.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn", + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get results of a swiss tournament + /// + /// Players of a swiss tournament, with their score and performance, sorted by rank (best first). + /// Players are streamed as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// If called on an ongoing tournament, results can be inconsistent + /// due to ranking changes while the players are being streamed. + /// Use on finished tournaments for guaranteed consistency. + /// + /// + /// - Remark: HTTP `GET /api/swiss/{id}/results`. + /// - Remark: Generated from `#/paths//api/swiss/{id}/results/get(resultsBySwiss)`. + internal func resultsBySwiss(_ input: Operations.resultsBySwiss.Input) async throws -> Operations.resultsBySwiss.Output { + try await client.send( + input: input, + forOperation: Operations.resultsBySwiss.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/swiss/{}/results", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "nb", + value: input.query.nb + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.resultsBySwiss.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.resultsBySwiss.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get team swiss tournaments + /// + /// Get all swiss tournaments of a team. + /// Tournaments are sorted by reverse chronological order of start date (last starting first). + /// Tournaments are streamed as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// + /// + /// - Remark: HTTP `GET /api/team/{teamId}/swiss`. + /// - Remark: Generated from `#/paths//api/team/{teamId}/swiss/get(apiTeamSwiss)`. + internal func apiTeamSwiss(_ input: Operations.apiTeamSwiss.Input) async throws -> Operations.apiTeamSwiss.Output { + try await client.send( + input: input, + forOperation: Operations.apiTeamSwiss.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/team/{}/swiss", + parameters: [ + input.path.teamId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "max", + value: input.query.max + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiTeamSwiss.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTeamSwiss.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/nd-json" + ] + ) + switch chosenContentType { + case "application/nd-json": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_nd_hyphen_json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export one study chapter + /// + /// Download one study chapter in PGN format. + /// + /// + /// - Remark: HTTP `GET /api/study/{studyId}/{chapterId}.pgn`. + /// - Remark: Generated from `#/paths//api/study/{studyId}/{chapterId}.pgn/get(studyChapterPgn)`. + internal func studyChapterPgn(_ input: Operations.studyChapterPgn.Input) async throws -> Operations.studyChapterPgn.Output { + try await client.send( + input: input, + forOperation: Operations.studyChapterPgn.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/study/{}/{}.pgn", + parameters: [ + input.path.studyId, + input.path.chapterId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "clocks", + value: input.query.clocks + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "comments", + value: input.query.comments + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "variations", + value: input.query.variations + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "source", + value: input.query.source + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "orientation", + value: input.query.orientation + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.studyChapterPgn.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export all chapters + /// + /// Download all chapters of a study in PGN format. + /// + /// + /// - Remark: HTTP `GET /api/study/{studyId}.pgn`. + /// - Remark: Generated from `#/paths//api/study/{studyId}.pgn/get(studyAllChaptersPgn)`. + internal func studyAllChaptersPgn(_ input: Operations.studyAllChaptersPgn.Input) async throws -> Operations.studyAllChaptersPgn.Output { + try await client.send( + input: input, + forOperation: Operations.studyAllChaptersPgn.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/study/{}.pgn", + parameters: [ + input.path.studyId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "clocks", + value: input.query.clocks + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "comments", + value: input.query.comments + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "variations", + value: input.query.variations + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "source", + value: input.query.source + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "orientation", + value: input.query.orientation + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.studyAllChaptersPgn.Output.Ok.Headers = .init( + Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + ), + Last_hyphen_Modified: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Last-Modified", + as: Swift.String.self + ) + ) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.studyAllChaptersPgn.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Study metadata + /// + /// Only get the study headers, including `Last-Modified`. + /// + /// + /// - Remark: HTTP `HEAD /api/study/{studyId}.pgn`. + /// - Remark: Generated from `#/paths//api/study/{studyId}.pgn/head(studyAllChaptersHead)`. + internal func studyAllChaptersHead(_ input: Operations.studyAllChaptersHead.Input) async throws -> Operations.studyAllChaptersHead.Output { + try await client.send( + input: input, + forOperation: Operations.studyAllChaptersHead.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/study/{}.pgn", + parameters: [ + input.path.studyId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .head + ) + suppressMutabilityWarning(&request) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.studyAllChaptersHead.Output.Ok.Headers = .init( + Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + ), + Last_hyphen_Modified: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Last-Modified", + as: Swift.String.self + ) + ) + return .ok(.init(headers: headers)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Import PGN into a study + /// + /// Imports arbitrary PGN into an existing [study](https://lichess.org/study). Creates a new chapter in the study. + /// If the PGN contains multiple games (separated by 2 or more newlines) + /// then multiple chapters will be created within the study. + /// Note that a study can contain at most 64 chapters. + /// + /// + /// - Remark: HTTP `POST /api/study/{studyId}/import-pgn`. + /// - Remark: Generated from `#/paths//api/study/{studyId}/import-pgn/post(apiStudyImportPGN)`. + internal func apiStudyImportPGN(_ input: Operations.apiStudyImportPGN.Input) async throws -> Operations.apiStudyImportPGN.Output { + try await client.send( + input: input, + forOperation: Operations.apiStudyImportPGN.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/study/{}/import-pgn", + parameters: [ + input.path.studyId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiStudyImportPGN.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiStudyImportPGN.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.StudyImportPgnChapters.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiStudyImportPGN.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export all studies of a user + /// + /// Download all chapters of all studies of a user in PGN format. + /// If authenticated, then all public, unlisted, and private studies are included. + /// If not, only public (non-unlisted) studies are included. + /// + /// + /// - Remark: HTTP `GET /study/by/{username}/export.pgn`. + /// - Remark: Generated from `#/paths//study/by/{username}/export.pgn/get(studyExportAllPgn)`. + internal func studyExportAllPgn(_ input: Operations.studyExportAllPgn.Input) async throws -> Operations.studyExportAllPgn.Output { + try await client.send( + input: input, + forOperation: Operations.studyExportAllPgn.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/study/by/{}/export.pgn", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "clocks", + value: input.query.clocks + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "comments", + value: input.query.comments + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "variations", + value: input.query.variations + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "source", + value: input.query.source + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "orientation", + value: input.query.orientation + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.studyExportAllPgn.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// List studies of a user + /// + /// Get metadata (name and dates) of all studies of a user. + /// If authenticated, then all public, unlisted, and private studies are included. + /// If not, only public (non-unlisted) studies are included. + /// Studies are streamed as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// + /// + /// - Remark: HTTP `GET /api/study/by/{username}`. + /// - Remark: Generated from `#/paths//api/study/by/{username}/get(studyListMetadata)`. + internal func studyListMetadata(_ input: Operations.studyListMetadata.Input) async throws -> Operations.studyListMetadata.Output { + try await client.send( + input: input, + forOperation: Operations.studyListMetadata.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/study/by/{}", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.studyListMetadata.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.studyListMetadata.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Delete a study chapter + /// + /// Delete a chapter of a study you own. This is definitive. + /// A study must have at least one chapter; so if you delete the last chapter, + /// an empty one will be automatically created to replace it. + /// + /// + /// - Remark: HTTP `DELETE /api/study/{studyId}/{chapterId}`. + /// - Remark: Generated from `#/paths//api/study/{studyId}/{chapterId}/delete(apiStudyStudyIdChapterIdDelete)`. + internal func apiStudyStudyIdChapterIdDelete(_ input: Operations.apiStudyStudyIdChapterIdDelete.Input) async throws -> Operations.apiStudyStudyIdChapterIdDelete.Output { + try await client.send( + input: input, + forOperation: Operations.apiStudyStudyIdChapterIdDelete.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/study/{}/{}", + parameters: [ + input.path.studyId, + input.path.chapterId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .delete + ) + suppressMutabilityWarning(&request) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 204: + let headers: Operations.apiStudyStudyIdChapterIdDelete.Output.NoContent.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + return .noContent(.init(headers: headers)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get official broadcasts + /// + /// Get all incoming, ongoing, and finished official broadcasts. + /// The broadcasts are sorted by start date, most recent first. + /// Broadcasts are streamed as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// + /// + /// - Remark: HTTP `GET /api/broadcast`. + /// - Remark: Generated from `#/paths//api/broadcast/get(broadcastIndex)`. + internal func broadcastIndex(_ input: Operations.broadcastIndex.Input) async throws -> Operations.broadcastIndex.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastIndex.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/broadcast", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "nb", + value: input.query.nb + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.broadcastIndex.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastIndex.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Create a broadcast tournament + /// + /// Create a new broadcast tournament to relay external games. + /// This endpoint accepts the same form data as the [web form](https://lichess.org/broadcast/new). + /// + /// + /// - Remark: HTTP `POST /broadcast/new`. + /// - Remark: Generated from `#/paths//broadcast/new/post(broadcastTourCreate)`. + internal func broadcastTourCreate(_ input: Operations.broadcastTourCreate.Input) async throws -> Operations.broadcastTourCreate.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastTourCreate.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/broadcast/new", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.broadcastTourCreate.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastTourCreate.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.BroadcastTour.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastTourCreate.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get a broadcast tournament + /// + /// Get information about a broadcast tournament. + /// + /// + /// - Remark: HTTP `GET /api/broadcast/{broadcastTournamentId}`. + /// - Remark: Generated from `#/paths//api/broadcast/{broadcastTournamentId}/get(broadcastTourGet)`. + internal func broadcastTourGet(_ input: Operations.broadcastTourGet.Input) async throws -> Operations.broadcastTourGet.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastTourGet.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/broadcast/{}", + parameters: [ + input.path.broadcastTournamentId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastTourGet.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.BroadcastTour.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get a broadcast leaderboard + /// + /// Get the leaderboard of a broadcast tournament, if available. + /// + /// + /// - Remark: HTTP `GET /broadcast/{broadcastTournamentId}/leaderboard`. + /// - Remark: Generated from `#/paths//broadcast/{broadcastTournamentId}/leaderboard/get(broadcastLeaderboardGet)`. + internal func broadcastLeaderboardGet(_ input: Operations.broadcastLeaderboardGet.Input) async throws -> Operations.broadcastLeaderboardGet.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastLeaderboardGet.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/broadcast/{}/leaderboard", + parameters: [ + input.path.broadcastTournamentId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastLeaderboardGet.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + [Components.Schemas.BroadcastLeaderboardEntry].self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Update your broadcast tournament + /// + /// Update information about a broadcast tournament that you created. + /// This endpoint accepts the same form data as the web form. + /// All fields must be populated with data. Missing fields will override the broadcast with empty data. + /// + /// + /// - Remark: HTTP `POST /broadcast/{broadcastTournamentId}/edit`. + /// - Remark: Generated from `#/paths//broadcast/{broadcastTournamentId}/edit/post(broadcastTourUpdate)`. + internal func broadcastTourUpdate(_ input: Operations.broadcastTourUpdate.Input) async throws -> Operations.broadcastTourUpdate.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastTourUpdate.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/broadcast/{}/edit", + parameters: [ + input.path.broadcastTournamentId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.broadcastTourUpdate.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastTourUpdate.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastTourUpdate.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Create a broadcast round + /// + /// Create a new broadcast round to relay external games. + /// This endpoint accepts the same form data as the web form. + /// + /// + /// - Remark: HTTP `POST /broadcast/{broadcastTournamentId}/new`. + /// - Remark: Generated from `#/paths//broadcast/{broadcastTournamentId}/new/post(broadcastRoundCreate)`. + internal func broadcastRoundCreate(_ input: Operations.broadcastRoundCreate.Input) async throws -> Operations.broadcastRoundCreate.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastRoundCreate.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/broadcast/{}/new", + parameters: [ + input.path.broadcastTournamentId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.broadcastRoundCreate.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastRoundCreate.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.BroadcastRound.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastRoundCreate.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get a broadcast round + /// + /// Get information about a broadcast round. + /// + /// + /// - Remark: HTTP `GET /api/broadcast/{broadcastTournamentSlug}/{broadcastRoundSlug}/{broadcastRoundId}`. + /// - Remark: Generated from `#/paths//api/broadcast/{broadcastTournamentSlug}/{broadcastRoundSlug}/{broadcastRoundId}/get(broadcastRoundGet)`. + internal func broadcastRoundGet(_ input: Operations.broadcastRoundGet.Input) async throws -> Operations.broadcastRoundGet.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastRoundGet.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/broadcast/{}/{}/{}", + parameters: [ + input.path.broadcastTournamentSlug, + input.path.broadcastRoundSlug, + input.path.broadcastRoundId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastRoundGet.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.BroadcastRound.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Update your broadcast round + /// + /// Update information about a broadcast round that you created. + /// This endpoint accepts the same form data as the web form. + /// All fields must be populated with data. Missing fields will override the broadcast with empty data. + /// For instance, if you omit `startDate`, then any pre-existing start date will be removed. + /// + /// + /// - Remark: HTTP `POST /broadcast/round/{broadcastRoundId}/edit`. + /// - Remark: Generated from `#/paths//broadcast/round/{broadcastRoundId}/edit/post(broadcastRoundUpdate)`. + internal func broadcastRoundUpdate(_ input: Operations.broadcastRoundUpdate.Input) async throws -> Operations.broadcastRoundUpdate.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastRoundUpdate.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/broadcast/round/{}/edit", + parameters: [ + input.path.broadcastRoundId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.broadcastRoundUpdate.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastRoundUpdate.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastRoundUpdate.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Push PGN to your broadcast round + /// + /// Update your broadcast with new PGN. + /// Only for broadcast without a source URL. + /// + /// + /// - Remark: HTTP `POST /broadcast/round/{broadcastRoundId}/push`. + /// - Remark: Generated from `#/paths//broadcast/round/{broadcastRoundId}/push/post(broadcastPush)`. + internal func broadcastPush(_ input: Operations.broadcastPush.Input) async throws -> Operations.broadcastPush.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastPush.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/broadcast/round/{}/push", + parameters: [ + input.path.broadcastRoundId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .plainText(value): + body = try converter.setRequiredRequestBodyAsBinary( + value, + headerFields: &request.headerFields, + contentType: "text/plain" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.broadcastPush.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastPush.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.BroadcastPgnPush.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let headers: Operations.broadcastPush.Output.BadRequest.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastPush.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Operations.broadcastPush.Output.BadRequest.Body.jsonPayload.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Stream an ongoing broadcast tournament as PGN + /// + /// This streaming endpoint first sends all games of a broadcast tournament in PGN format. + /// Then, it waits for new moves to be played. As soon as it happens, the entire PGN of the game is sent to the stream. + /// The stream will also send PGNs when games are added to the tournament. + /// This is the best way to get updates about an ongoing tournament. Streaming means no polling, + /// and no pollings means no latency, and minimum impact on the server. + /// + /// + /// - Remark: HTTP `GET /api/stream/broadcast/round/{broadcastRoundId}.pgn`. + /// - Remark: Generated from `#/paths//api/stream/broadcast/round/{broadcastRoundId}.pgn/get(broadcastStreamRoundPgn)`. + internal func broadcastStreamRoundPgn(_ input: Operations.broadcastStreamRoundPgn.Input) async throws -> Operations.broadcastStreamRoundPgn.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastStreamRoundPgn.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/stream/broadcast/round/{}.pgn", + parameters: [ + input.path.broadcastRoundId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.broadcastStreamRoundPgn.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastStreamRoundPgn.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export one round as PGN + /// + /// Download all games of a single round of a broadcast tournament in PGN format. + /// You *could* poll this endpoint to get updates about a tournament, but it would be slow, + /// and very inefficient. + /// Instead, consider [streaming the tournament](#operation/broadcastStreamRoundPgn) to get + /// a new PGN every time a game is updated, in real-time. + /// + /// + /// - Remark: HTTP `GET /api/broadcast/round/{broadcastRoundId}.pgn`. + /// - Remark: Generated from `#/paths//api/broadcast/round/{broadcastRoundId}.pgn/get(broadcastRoundPgn)`. + internal func broadcastRoundPgn(_ input: Operations.broadcastRoundPgn.Input) async throws -> Operations.broadcastRoundPgn.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastRoundPgn.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/broadcast/round/{}.pgn", + parameters: [ + input.path.broadcastRoundId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.broadcastRoundPgn.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastRoundPgn.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Export all rounds as PGN + /// + /// Download all games of all rounds of a broadcast in PGN format. + /// If a `study:read` [OAuth token](#tag/OAuth) is provided, + /// the private rounds where the user is a contributor will be available. + /// You may want to [download only the games of a single round](#operation/broadcastRoundPgn) instead. + /// + /// + /// - Remark: HTTP `GET /api/broadcast/{broadcastTournamentId}.pgn`. + /// - Remark: Generated from `#/paths//api/broadcast/{broadcastTournamentId}.pgn/get(broadcastAllRoundsPgn)`. + internal func broadcastAllRoundsPgn(_ input: Operations.broadcastAllRoundsPgn.Input) async throws -> Operations.broadcastAllRoundsPgn.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastAllRoundsPgn.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/broadcast/{}.pgn", + parameters: [ + input.path.broadcastTournamentId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.broadcastAllRoundsPgn.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastAllRoundsPgn.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get your broadcast rounds + /// + /// Stream all broadcast rounds you are a member of. + /// Also includes broadcasts rounds you did not create, but were invited to. + /// Also includes broadcasts rounds where you're a non-writing member. See the `writeable` flag in the response. + /// Rounds are ordered by rank, which is roughly chronological, most recent first, slightly pondered with popularity. + /// + /// + /// - Remark: HTTP `GET /api/broadcast/my-rounds`. + /// - Remark: Generated from `#/paths//api/broadcast/my-rounds/get(broadcastMyRoundsGet)`. + internal func broadcastMyRoundsGet(_ input: Operations.broadcastMyRoundsGet.Input) async throws -> Operations.broadcastMyRoundsGet.Output { + try await client.send( + input: input, + forOperation: Operations.broadcastMyRoundsGet.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/broadcast/my-rounds", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "nb", + value: input.query.nb + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.broadcastMyRoundsGet.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.BroadcastMyRound.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get current simuls + /// + /// Get recently created, started, finished, simuls. + /// Created and finished simul lists are not exhaustives, only those with + /// strong enough host will be listed, the same filter is used to display simuls on https://lichess.org/simul. + /// When [authenticated with OAuth2](#section/Introduction/Authentication), the pending list will be populated with your created, but unstarted simuls. + /// + /// + /// - Remark: HTTP `GET /api/simul`. + /// - Remark: Generated from `#/paths//api/simul/get(apiSimul)`. + internal func apiSimul(_ input: Operations.apiSimul.Input) async throws -> Operations.apiSimul.Output { + try await client.send( + input: input, + forOperation: Operations.apiSimul.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/simul", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiSimul.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiSimul.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Operations.apiSimul.Output.Ok.Body.jsonPayload.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get a single team + /// + /// Public info about a team. Includes the list of publicly visible leaders. + /// + /// - Remark: HTTP `GET /api/team/{teamId}`. + /// - Remark: Generated from `#/paths//api/team/{teamId}/get(teamShow)`. + internal func teamShow(_ input: Operations.teamShow.Input) async throws -> Operations.teamShow.Output { + try await client.send( + input: input, + forOperation: Operations.teamShow.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/team/{}", + parameters: [ + input.path.teamId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.teamShow.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamShow.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Team.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get popular teams + /// + /// Paginator of the most popular teams. + /// + /// + /// - Remark: HTTP `GET /api/team/all`. + /// - Remark: Generated from `#/paths//api/team/all/get(teamAll)`. + internal func teamAll(_ input: Operations.teamAll.Input) async throws -> Operations.teamAll.Output { + try await client.send( + input: input, + forOperation: Operations.teamAll.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/team/all", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "page", + value: input.query.page + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.teamAll.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamAll.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.TeamPaginatorJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Teams of a player + /// + /// All the teams a player is a member of. + /// + /// + /// - Remark: HTTP `GET /api/team/of/{username}`. + /// - Remark: Generated from `#/paths//api/team/of/{username}/get(teamOfUsername)`. + internal func teamOfUsername(_ input: Operations.teamOfUsername.Input) async throws -> Operations.teamOfUsername.Output { + try await client.send( + input: input, + forOperation: Operations.teamOfUsername.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/team/of/{}", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.teamOfUsername.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamOfUsername.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + [Components.Schemas.Team].self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Search teams + /// + /// Paginator of team search results for a keyword. + /// + /// + /// - Remark: HTTP `GET /api/team/search`. + /// - Remark: Generated from `#/paths//api/team/search/get(teamSearch)`. + internal func teamSearch(_ input: Operations.teamSearch.Input) async throws -> Operations.teamSearch.Output { + try await client.send( + input: input, + forOperation: Operations.teamSearch.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/team/search", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "text", + value: input.query.text + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "page", + value: input.query.page + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.teamSearch.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamSearch.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.TeamPaginatorJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get members of a team + /// + /// Members are sorted by reverse chronological order of joining the team (most recent first). + /// OAuth is only required if the list of members is private. + /// Members are streamed as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// + /// + /// - Remark: HTTP `GET /api/team/{teamId}/users`. + /// - Remark: Generated from `#/paths//api/team/{teamId}/users/get(teamIdUsers)`. + internal func teamIdUsers(_ input: Operations.teamIdUsers.Input) async throws -> Operations.teamIdUsers.Output { + try await client.send( + input: input, + forOperation: Operations.teamIdUsers.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/team/{}/users", + parameters: [ + input.path.teamId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.teamIdUsers.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamIdUsers.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get team Arena tournaments + /// + /// Get all Arena tournaments relevant to a team. + /// Tournaments are sorted by reverse chronological order of start date (last starting first). + /// Tournaments are streamed as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// + /// + /// - Remark: HTTP `GET /api/team/{teamId}/arena`. + /// - Remark: Generated from `#/paths//api/team/{teamId}/arena/get(apiTeamArena)`. + internal func apiTeamArena(_ input: Operations.apiTeamArena.Input) async throws -> Operations.apiTeamArena.Output { + try await client.send( + input: input, + forOperation: Operations.apiTeamArena.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/team/{}/arena", + parameters: [ + input.path.teamId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "max", + value: input.query.max + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiTeamArena.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiTeamArena.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Join a team + /// + /// Join a team. + /// If the team requires a password but the `password` field is incorrect, + /// then the call fails with `403 Forbidden`. + /// Similarly, if the team join policy requires a confirmation but the + /// `message` parameter is not given, then the call fails with + /// `403 Forbidden`. + /// + /// + /// - Remark: HTTP `POST /team/{teamId}/join`. + /// - Remark: Generated from `#/paths//team/{teamId}/join/post(teamIdJoin)`. + internal func teamIdJoin(_ input: Operations.teamIdJoin.Input) async throws -> Operations.teamIdJoin.Output { + try await client.send( + input: input, + forOperation: Operations.teamIdJoin.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/team/{}/join", + parameters: [ + input.path.teamId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamIdJoin.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Leave a team + /// + /// Leave a team. + /// - <https://lichess.org/team> + /// + /// + /// - Remark: HTTP `POST /team/{teamId}/quit`. + /// - Remark: Generated from `#/paths//team/{teamId}/quit/post(teamIdQuit)`. + internal func teamIdQuit(_ input: Operations.teamIdQuit.Input) async throws -> Operations.teamIdQuit.Output { + try await client.send( + input: input, + forOperation: Operations.teamIdQuit.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/team/{}/quit", + parameters: [ + input.path.teamId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamIdQuit.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get join requests + /// + /// Get pending join requests of your team + /// + /// - Remark: HTTP `GET /api/team/{teamId}/requests`. + /// - Remark: Generated from `#/paths//api/team/{teamId}/requests/get(teamRequests)`. + internal func teamRequests(_ input: Operations.teamRequests.Input) async throws -> Operations.teamRequests.Output { + try await client.send( + input: input, + forOperation: Operations.teamRequests.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/team/{}/requests", + parameters: [ + input.path.teamId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "declined", + value: input.query.declined + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamRequests.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + [Components.Schemas.TeamRequestWithUser].self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Accept join request + /// + /// Accept someone's request to join your team + /// + /// - Remark: HTTP `POST /api/team/{teamId}/request/{userId}/accept`. + /// - Remark: Generated from `#/paths//api/team/{teamId}/request/{userId}/accept/post(teamRequestAccept)`. + internal func teamRequestAccept(_ input: Operations.teamRequestAccept.Input) async throws -> Operations.teamRequestAccept.Output { + try await client.send( + input: input, + forOperation: Operations.teamRequestAccept.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/team/{}/request/{}/accept", + parameters: [ + input.path.teamId, + input.path.userId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamRequestAccept.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Decline join request + /// + /// Decline someone's request to join your team + /// + /// - Remark: HTTP `POST /api/team/{teamId}/request/{userId}/decline`. + /// - Remark: Generated from `#/paths//api/team/{teamId}/request/{userId}/decline/post(teamRequestDecline)`. + internal func teamRequestDecline(_ input: Operations.teamRequestDecline.Input) async throws -> Operations.teamRequestDecline.Output { + try await client.send( + input: input, + forOperation: Operations.teamRequestDecline.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/team/{}/request/{}/decline", + parameters: [ + input.path.teamId, + input.path.userId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamRequestDecline.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Kick a user from your team + /// + /// Kick a member out of one of your teams. + /// - <https://lichess.org/team> + /// + /// + /// - Remark: HTTP `POST /api/team/{teamId}/kick/{userId}`. + /// - Remark: Generated from `#/paths//api/team/{teamId}/kick/{userId}/post(teamIdKickUserId)`. + internal func teamIdKickUserId(_ input: Operations.teamIdKickUserId.Input) async throws -> Operations.teamIdKickUserId.Output { + try await client.send( + input: input, + forOperation: Operations.teamIdKickUserId.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/team/{}/kick/{}", + parameters: [ + input.path.teamId, + input.path.userId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamIdKickUserId.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Message all members + /// + /// Send a private message to all members of a team. + /// You must be a team leader with the "Messages" permission. + /// + /// + /// - Remark: HTTP `POST /team/{teamId}/pm-all`. + /// - Remark: Generated from `#/paths//team/{teamId}/pm-all/post(teamIdPmAll)`. + internal func teamIdPmAll(_ input: Operations.teamIdPmAll.Input) async throws -> Operations.teamIdPmAll.Output { + try await client.send( + input: input, + forOperation: Operations.teamIdPmAll.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/team/{}/pm-all", + parameters: [ + input.path.teamId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.teamIdPmAll.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamIdPmAll.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.teamIdPmAll.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get live streamers + /// + /// Get basic info about currently streaming users. + /// This API is very fast and cheap on lichess side. + /// So you can call it quite often (like once every 5 seconds). + /// + /// + /// - Remark: HTTP `GET /api/streamer/live`. + /// - Remark: Generated from `#/paths//api/streamer/live/get(streamerLive)`. + internal func streamerLive(_ input: Operations.streamerLive.Input) async throws -> Operations.streamerLive.Output { + try await client.send( + input: input, + forOperation: Operations.streamerLive.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/streamer/live", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.streamerLive.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.streamerLive.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + [Components.Schemas.LightUser].self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get crosstable + /// + /// Get total number of games, and current score, of any two users. + /// If the `matchup` flag is provided, and the users are currently playing, also gets the current match game number and scores. + /// + /// + /// - Remark: HTTP `GET /api/crosstable/{user1}/{user2}`. + /// - Remark: Generated from `#/paths//api/crosstable/{user1}/{user2}/get(apiCrosstable)`. + internal func apiCrosstable(_ input: Operations.apiCrosstable.Input) async throws -> Operations.apiCrosstable.Output { + try await client.send( + input: input, + forOperation: Operations.apiCrosstable.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/crosstable/{}/{}", + parameters: [ + input.path.user1, + input.path.user2 + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "matchup", + value: input.query.matchup + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiCrosstable.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiCrosstable.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Crosstable.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Autocomplete usernames + /// + /// Provides autocompletion options for an incomplete username. + /// + /// + /// - Remark: HTTP `GET /api/player/autocomplete`. + /// - Remark: Generated from `#/paths//api/player/autocomplete/get(apiPlayerAutocomplete)`. + internal func apiPlayerAutocomplete(_ input: Operations.apiPlayerAutocomplete.Input) async throws -> Operations.apiPlayerAutocomplete.Output { + try await client.send( + input: input, + forOperation: Operations.apiPlayerAutocomplete.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/player/autocomplete", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "term", + value: input.query.term + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "object", + value: input.query.object + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "friend", + value: input.query.friend + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiPlayerAutocomplete.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiPlayerAutocomplete.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Operations.apiPlayerAutocomplete.Output.Ok.Body.jsonPayload.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get notes for a user + /// + /// Get the private notes that you have added for a user. + /// + /// + /// - Remark: HTTP `GET /api/user/{username}/note`. + /// - Remark: Generated from `#/paths//api/user/{username}/note/get(readNote)`. + internal func readNote(_ input: Operations.readNote.Input) async throws -> Operations.readNote.Output { + try await client.send( + input: input, + forOperation: Operations.readNote.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/user/{}/note", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.readNote.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.readNote.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + [Components.Schemas.UserNote].self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Add a note for a user + /// + /// Add a private note available only to you about this account. + /// + /// + /// - Remark: HTTP `POST /api/user/{username}/note`. + /// - Remark: Generated from `#/paths//api/user/{username}/note/post(writeNote)`. + internal func writeNote(_ input: Operations.writeNote.Input) async throws -> Operations.writeNote.Output { + try await client.send( + input: input, + forOperation: Operations.writeNote.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/user/{}/note", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.writeNote.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get users followed by the logged in user + /// + /// Users are streamed as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// + /// + /// - Remark: HTTP `GET /api/rel/following`. + /// - Remark: Generated from `#/paths//api/rel/following/get(apiUserFollowing)`. + internal func apiUserFollowing(_ input: Operations.apiUserFollowing.Input) async throws -> Operations.apiUserFollowing.Output { + try await client.send( + input: input, + forOperation: Operations.apiUserFollowing.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/rel/following", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiUserFollowing.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiUserFollowing.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Follow a player + /// + /// Follow a player, adding them to your list of Lichess friends. + /// + /// + /// - Remark: HTTP `POST /api/rel/follow/{username}`. + /// - Remark: Generated from `#/paths//api/rel/follow/{username}/post(followUser)`. + internal func followUser(_ input: Operations.followUser.Input) async throws -> Operations.followUser.Output { + try await client.send( + input: input, + forOperation: Operations.followUser.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/rel/follow/{}", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.followUser.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Unfollow a player + /// + /// Unfollow a player, removing them from your list of Lichess friends. + /// + /// + /// - Remark: HTTP `POST /api/rel/unfollow/{username}`. + /// - Remark: Generated from `#/paths//api/rel/unfollow/{username}/post(unfollowUser)`. + internal func unfollowUser(_ input: Operations.unfollowUser.Input) async throws -> Operations.unfollowUser.Output { + try await client.send( + input: input, + forOperation: Operations.unfollowUser.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/rel/unfollow/{}", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.unfollowUser.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Stream incoming events + /// + /// + /// Stream the events reaching a lichess user in real time as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// + /// An empty line is sent every 6 seconds for keep alive purposes. + /// + /// Each non-empty line is a JSON object containing a `type` field. Possible values are: + /// - `gameStart` Start of a game + /// - `gameFinish` Completion of a game + /// - `challenge` A player sends you a challenge or you challenge someone + /// - `challengeCanceled` A player cancels their challenge to you + /// - `challengeDeclined` The opponent declines your challenge + /// + /// When the stream opens, all current challenges and games are sent. + /// + /// - Remark: HTTP `GET /api/stream/event`. + /// - Remark: Generated from `#/paths//api/stream/event/get(apiStreamEvent)`. + internal func apiStreamEvent(_ input: Operations.apiStreamEvent.Input) async throws -> Operations.apiStreamEvent.Output { + try await client.send( + input: input, + forOperation: Operations.apiStreamEvent.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/stream/event", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiStreamEvent.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiStreamEvent.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Create a seek + /// + /// + /// Create a public seek, to start a game with a random player. + /// + /// ### Real-time seek + /// + /// Specify the `time` and `increment` clock values. The response is streamed but doesn't contain any information. + /// + /// **Keep the connection open to keep the seek active**. + /// + /// If the client closes the connection, the seek is canceled. This way, if the client terminates, the user won't be paired in a game they wouldn't play. + /// When the seek is accepted, or expires, the server closes the connection. + /// + /// **Make sure to also have an [Event stream](#operation/apiStreamEvent) open**, to be notified when a game starts. + /// We recommend opening the [Event stream](#operation/apiStreamEvent) first, then the seek stream. This way, + /// you won't miss the game event if the seek is accepted immediately. + /// + /// ### Correspondence seek + /// + /// Specify the `days` per turn value. The response is not streamed, it immediately completes with the seek ID. The seek remains active on the server until it is joined by someone. + /// + /// - Remark: HTTP `POST /api/board/seek`. + /// - Remark: Generated from `#/paths//api/board/seek/post(apiBoardSeek)`. + internal func apiBoardSeek(_ input: Operations.apiBoardSeek.Input) async throws -> Operations.apiBoardSeek.Output { + try await client.send( + input: input, + forOperation: Operations.apiBoardSeek.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/board/seek", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiBoardSeek.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiBoardSeek.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "text/plain" + ] + ) + switch chosenContentType { + case "text/plain": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .plainText(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiBoardSeek.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Stream Board game state + /// + /// Stream the state of a game being played with the Board API, as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// + /// Use this endpoint to get updates about the game in real-time, with a single request. + /// + /// Each line is a JSON object containing a `type` field. Possible values are: + /// - `gameFull` Full game data. All values are immutable, except for the `state` field. + /// - `gameState` Current state of the game. Immutable values not included. Sent when a move is played, a draw is offered, or when the game ends. + /// - `chatLine` Chat message sent by a user in the `room` "player" or "spectator". + /// + /// - `opponentGone` Whether the opponent has left the game, and how long before you can claim a win or draw. + /// + /// + /// The first line is always of type `gameFull`. + /// + /// + /// The server closes the stream when the game ends, or if the game has already ended. + /// + /// - Remark: HTTP `GET /api/board/game/stream/{gameId}`. + /// - Remark: Generated from `#/paths//api/board/game/stream/{gameId}/get(boardGameStream)`. + internal func boardGameStream(_ input: Operations.boardGameStream.Input) async throws -> Operations.boardGameStream.Output { + try await client.send( + input: input, + forOperation: Operations.boardGameStream.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/board/game/stream/{}", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.boardGameStream.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameStream.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 404: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameStream.Output.NotFound.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.NotFound.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .notFound(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Make a Board move + /// + /// Make a move in a game being played with the Board API. + /// The move can also contain a draw offer/agreement. + /// + /// + /// - Remark: HTTP `POST /api/board/game/{gameId}/move/{move}`. + /// - Remark: Generated from `#/paths//api/board/game/{gameId}/move/{move}/post(boardGameMove)`. + internal func boardGameMove(_ input: Operations.boardGameMove.Input) async throws -> Operations.boardGameMove.Output { + try await client.send( + input: input, + forOperation: Operations.boardGameMove.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/board/game/{}/move/{}", + parameters: [ + input.path.gameId, + input.path.move + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "offeringDraw", + value: input.query.offeringDraw + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.boardGameMove.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameMove.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameMove.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Fetch the game chat + /// + /// Get the messages posted in the game chat + /// + /// + /// - Remark: HTTP `GET /api/board/game/{gameId}/chat`. + /// - Remark: Generated from `#/paths//api/board/game/{gameId}/chat/get(boardGameChatGet)`. + internal func boardGameChatGet(_ input: Operations.boardGameChatGet.Input) async throws -> Operations.boardGameChatGet.Output { + try await client.send( + input: input, + forOperation: Operations.boardGameChatGet.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/board/game/{}/chat", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.boardGameChatGet.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameChatGet.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Write in the chat + /// + /// Post a message to the player or spectator chat, in a game being played with the Board API. + /// + /// + /// - Remark: HTTP `POST /api/board/game/{gameId}/chat`. + /// - Remark: Generated from `#/paths//api/board/game/{gameId}/chat/post(boardGameChatPost)`. + internal func boardGameChatPost(_ input: Operations.boardGameChatPost.Input) async throws -> Operations.boardGameChatPost.Output { + try await client.send( + input: input, + forOperation: Operations.boardGameChatPost.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/board/game/{}/chat", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.boardGameChatPost.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameChatPost.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameChatPost.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Abort a game + /// + /// Abort a game being played with the Board API. + /// + /// + /// - Remark: HTTP `POST /api/board/game/{gameId}/abort`. + /// - Remark: Generated from `#/paths//api/board/game/{gameId}/abort/post(boardGameAbort)`. + internal func boardGameAbort(_ input: Operations.boardGameAbort.Input) async throws -> Operations.boardGameAbort.Output { + try await client.send( + input: input, + forOperation: Operations.boardGameAbort.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/board/game/{}/abort", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.boardGameAbort.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameAbort.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameAbort.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Resign a game + /// + /// Resign a game being played with the Board API. + /// + /// + /// - Remark: HTTP `POST /api/board/game/{gameId}/resign`. + /// - Remark: Generated from `#/paths//api/board/game/{gameId}/resign/post(boardGameResign)`. + internal func boardGameResign(_ input: Operations.boardGameResign.Input) async throws -> Operations.boardGameResign.Output { + try await client.send( + input: input, + forOperation: Operations.boardGameResign.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/board/game/{}/resign", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.boardGameResign.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameResign.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameResign.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Handle draw offers + /// + /// Create/accept/decline draw offers. + /// - `yes`: Offer a draw, or accept the opponent's draw offer. + /// - `no`: Decline a draw offer from the opponent. + /// + /// + /// - Remark: HTTP `POST /api/board/game/{gameId}/draw/{accept}`. + /// - Remark: Generated from `#/paths//api/board/game/{gameId}/draw/{accept}/post(boardGameDraw)`. + internal func boardGameDraw(_ input: Operations.boardGameDraw.Input) async throws -> Operations.boardGameDraw.Output { + try await client.send( + input: input, + forOperation: Operations.boardGameDraw.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/board/game/{}/draw/{}", + parameters: [ + input.path.gameId, + input.path.accept + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.boardGameDraw.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameDraw.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameDraw.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Handle takeback offers + /// + /// Create/accept/decline takebacks. + /// - `yes`: Propose a takeback, or accept the opponent's takeback offer. + /// - `no`: Decline a takeback offer from the opponent. + /// + /// + /// - Remark: HTTP `POST /api/board/game/{gameId}/takeback/{accept}`. + /// - Remark: Generated from `#/paths//api/board/game/{gameId}/takeback/{accept}/post(boardGameTakeback)`. + internal func boardGameTakeback(_ input: Operations.boardGameTakeback.Input) async throws -> Operations.boardGameTakeback.Output { + try await client.send( + input: input, + forOperation: Operations.boardGameTakeback.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/board/game/{}/takeback/{}", + parameters: [ + input.path.gameId, + input.path.accept + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.boardGameTakeback.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameTakeback.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameTakeback.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Claim victory of a game + /// + /// Claim victory when the opponent has left the game for a while. + /// + /// + /// - Remark: HTTP `POST /api/board/game/{gameId}/claim-victory`. + /// - Remark: Generated from `#/paths//api/board/game/{gameId}/claim-victory/post(boardGameClaimVictory)`. + internal func boardGameClaimVictory(_ input: Operations.boardGameClaimVictory.Input) async throws -> Operations.boardGameClaimVictory.Output { + try await client.send( + input: input, + forOperation: Operations.boardGameClaimVictory.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/board/game/{}/claim-victory", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.boardGameClaimVictory.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameClaimVictory.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameClaimVictory.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Berserk a tournament game + /// + /// Go berserk on an arena tournament game. Halves the clock time, grants an extra point upon winning. + /// Only available in arena tournaments that allow berserk, and before each player has made a move. + /// + /// + /// - Remark: HTTP `POST /api/board/game/{gameId}/berserk`. + /// - Remark: Generated from `#/paths//api/board/game/{gameId}/berserk/post(boardGameBerserk)`. + internal func boardGameBerserk(_ input: Operations.boardGameBerserk.Input) async throws -> Operations.boardGameBerserk.Output { + try await client.send( + input: input, + forOperation: Operations.boardGameBerserk.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/board/game/{}/berserk", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.boardGameBerserk.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameBerserk.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.boardGameBerserk.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get online bots + /// + /// Stream the [online bot users](https://lichess.org/player/bots), as [ndjson](#section/Introduction/Streaming-with-ND-JSON). Throttled to 50 bot users per second. + /// + /// - Remark: HTTP `GET /api/bot/online`. + /// - Remark: Generated from `#/paths//api/bot/online/get(apiBotOnline)`. + internal func apiBotOnline(_ input: Operations.apiBotOnline.Input) async throws -> Operations.apiBotOnline.Output { + try await client.send( + input: input, + forOperation: Operations.apiBotOnline.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bot/online", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "nb", + value: input.query.nb + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiBotOnline.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiBotOnline.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Upgrade to Bot account + /// + /// Upgrade a lichess player account into a Bot account. Only Bot accounts can use the Bot API. + /// The account **cannot have played any game** before becoming a Bot account. The upgrade is **irreversible**. The account will only be able to play as a Bot. + /// To upgrade an account to Bot, use the [official lichess-bot client](https://github.com/lichess-bot-devs/lichess-bot), or follow these steps: + /// - Create an [API access token](https://lichess.org/account/oauth/token/create?scopes[]=bot:play) with "Play bot moves" permission. + /// - `curl -d '' https://lichess.org/api/bot/account/upgrade -H "Authorization: Bearer <yourTokenHere>"` + /// To know if an account has already been upgraded, use the [Get my profile API](#operation/accountMe): + /// the `title` field should be set to `BOT`. + /// + /// + /// - Remark: HTTP `POST /api/bot/account/upgrade`. + /// - Remark: Generated from `#/paths//api/bot/account/upgrade/post(botAccountUpgrade)`. + internal func botAccountUpgrade(_ input: Operations.botAccountUpgrade.Input) async throws -> Operations.botAccountUpgrade.Output { + try await client.send( + input: input, + forOperation: Operations.botAccountUpgrade.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bot/account/upgrade", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.botAccountUpgrade.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botAccountUpgrade.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botAccountUpgrade.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Stream Bot game state + /// + /// Stream the state of a game being played with the Bot API, as [ndjson](#section/Introduction/Streaming-with-ND-JSON). + /// + /// Use this endpoint to get updates about the game in real-time, with a single request. + /// + /// Each line is a JSON object containing a `type` field. Possible values are: + /// - `gameFull` Full game data. All values are immutable, except for the `state` field. + /// - `gameState` Current state of the game. Immutable values not included. + /// - `chatLine` Chat message sent by a user (or the bot itself) in the `room` "player" or "spectator". + /// + /// - `opponentGone` Whether the opponent has left the game, and how long before you can claim a win or draw. + /// + /// + /// The first line is always of type `gameFull`. + /// + /// - Remark: HTTP `GET /api/bot/game/stream/{gameId}`. + /// - Remark: Generated from `#/paths//api/bot/game/stream/{gameId}/get(botGameStream)`. + internal func botGameStream(_ input: Operations.botGameStream.Input) async throws -> Operations.botGameStream.Output { + try await client.send( + input: input, + forOperation: Operations.botGameStream.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bot/game/stream/{}", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.botGameStream.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameStream.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 404: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameStream.Output.NotFound.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.NotFound.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .notFound(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Make a Bot move + /// + /// Make a move in a game being played with the Bot API. + /// The move can also contain a draw offer/agreement. + /// + /// + /// - Remark: HTTP `POST /api/bot/game/{gameId}/move/{move}`. + /// - Remark: Generated from `#/paths//api/bot/game/{gameId}/move/{move}/post(botGameMove)`. + internal func botGameMove(_ input: Operations.botGameMove.Input) async throws -> Operations.botGameMove.Output { + try await client.send( + input: input, + forOperation: Operations.botGameMove.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bot/game/{}/move/{}", + parameters: [ + input.path.gameId, + input.path.move + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "offeringDraw", + value: input.query.offeringDraw + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.botGameMove.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameMove.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameMove.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Fetch the game chat + /// + /// Get the messages posted in the game chat + /// + /// + /// - Remark: HTTP `GET /api/bot/game/{gameId}/chat`. + /// - Remark: Generated from `#/paths//api/bot/game/{gameId}/chat/get(botGameChatGet)`. + internal func botGameChatGet(_ input: Operations.botGameChatGet.Input) async throws -> Operations.botGameChatGet.Output { + try await client.send( + input: input, + forOperation: Operations.botGameChatGet.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bot/game/{}/chat", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.botGameChatGet.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameChatGet.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Write in the chat + /// + /// Post a message to the player or spectator chat, in a game being played with the Bot API. + /// + /// + /// - Remark: HTTP `POST /api/bot/game/{gameId}/chat`. + /// - Remark: Generated from `#/paths//api/bot/game/{gameId}/chat/post(botGameChat)`. + internal func botGameChat(_ input: Operations.botGameChat.Input) async throws -> Operations.botGameChat.Output { + try await client.send( + input: input, + forOperation: Operations.botGameChat.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bot/game/{}/chat", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.botGameChat.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameChat.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameChat.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Abort a game + /// + /// Abort a game being played with the Bot API. + /// + /// + /// - Remark: HTTP `POST /api/bot/game/{gameId}/abort`. + /// - Remark: Generated from `#/paths//api/bot/game/{gameId}/abort/post(botGameAbort)`. + internal func botGameAbort(_ input: Operations.botGameAbort.Input) async throws -> Operations.botGameAbort.Output { + try await client.send( + input: input, + forOperation: Operations.botGameAbort.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bot/game/{}/abort", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.botGameAbort.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameAbort.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameAbort.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Resign a game + /// + /// Resign a game being played with the Bot API. + /// + /// + /// - Remark: HTTP `POST /api/bot/game/{gameId}/resign`. + /// - Remark: Generated from `#/paths//api/bot/game/{gameId}/resign/post(botGameResign)`. + internal func botGameResign(_ input: Operations.botGameResign.Input) async throws -> Operations.botGameResign.Output { + try await client.send( + input: input, + forOperation: Operations.botGameResign.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bot/game/{}/resign", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.botGameResign.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameResign.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameResign.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Handle draw offers + /// + /// Create/accept/decline draw offers with the Bot API. + /// - `yes`: Offer a draw, or accept the opponent's draw offer. + /// - `no`: Decline a draw offer from the opponent. + /// + /// + /// - Remark: HTTP `POST /api/bot/game/{gameId}/draw/{accept}`. + /// - Remark: Generated from `#/paths//api/bot/game/{gameId}/draw/{accept}/post(botGameDraw)`. + internal func botGameDraw(_ input: Operations.botGameDraw.Input) async throws -> Operations.botGameDraw.Output { + try await client.send( + input: input, + forOperation: Operations.botGameDraw.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bot/game/{}/draw/{}", + parameters: [ + input.path.gameId, + input.path.accept + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.botGameDraw.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameDraw.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameDraw.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Handle takeback offers + /// + /// Create/accept/decline takebacks with the Bot API. + /// - `yes`: Propose a takeback, or accept the opponent's takeback offer. + /// - `no`: Decline a takeback offer from the opponent. + /// + /// + /// - Remark: HTTP `POST /api/bot/game/{gameId}/takeback/{accept}`. + /// - Remark: Generated from `#/paths//api/bot/game/{gameId}/takeback/{accept}/post(botGameTakeback)`. + internal func botGameTakeback(_ input: Operations.botGameTakeback.Input) async throws -> Operations.botGameTakeback.Output { + try await client.send( + input: input, + forOperation: Operations.botGameTakeback.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bot/game/{}/takeback/{}", + parameters: [ + input.path.gameId, + input.path.accept + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.botGameTakeback.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameTakeback.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.botGameTakeback.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// List your challenges + /// + /// Get a list of challenges created by or targeted at you. + /// + /// + /// - Remark: HTTP `GET /api/challenge`. + /// - Remark: Generated from `#/paths//api/challenge/get(challengeList)`. + internal func challengeList(_ input: Operations.challengeList.Input) async throws -> Operations.challengeList.Output { + try await client.send( + input: input, + forOperation: Operations.challengeList.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/challenge", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.challengeList.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeList.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Operations.challengeList.Output.Ok.Body.jsonPayload.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Create a challenge + /// + /// Challenge someone to play. The targeted player can choose to accept or decline. + /// If the challenge is accepted, you will be notified on the [event stream](#operation/apiStreamEvent) + /// that a new game has started. The game ID will be the same as the challenge ID. + /// Challenges for realtime games (not correspondence) expire after 20s if not accepted. + /// To prevent that, use the `keepAliveStream` flag described below. + /// + /// + /// - Remark: HTTP `POST /api/challenge/{username}`. + /// - Remark: Generated from `#/paths//api/challenge/{username}/post(challengeCreate)`. + internal func challengeCreate(_ input: Operations.challengeCreate.Input) async throws -> Operations.challengeCreate.Output { + try await client.send( + input: input, + forOperation: Operations.challengeCreate.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/challenge/{}", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.challengeCreate.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeCreate.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Operations.challengeCreate.Output.Ok.Body.jsonPayload.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeCreate.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Accept a challenge + /// + /// Accept an incoming challenge. + /// You should receive a `gameStart` event on the [incoming events stream](#operation/apiStreamEvent). + /// + /// + /// - Remark: HTTP `POST /api/challenge/{challengeId}/accept`. + /// - Remark: Generated from `#/paths//api/challenge/{challengeId}/accept/post(challengeAccept)`. + internal func challengeAccept(_ input: Operations.challengeAccept.Input) async throws -> Operations.challengeAccept.Output { + try await client.send( + input: input, + forOperation: Operations.challengeAccept.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/challenge/{}/accept", + parameters: [ + input.path.challengeId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.challengeAccept.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeAccept.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 404: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeAccept.Output.NotFound.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.NotFound.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .notFound(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Decline a challenge + /// + /// Decline an incoming challenge. + /// + /// + /// - Remark: HTTP `POST /api/challenge/{challengeId}/decline`. + /// - Remark: Generated from `#/paths//api/challenge/{challengeId}/decline/post(challengeDecline)`. + internal func challengeDecline(_ input: Operations.challengeDecline.Input) async throws -> Operations.challengeDecline.Output { + try await client.send( + input: input, + forOperation: Operations.challengeDecline.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/challenge/{}/decline", + parameters: [ + input.path.challengeId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case .none: + body = nil + case let .urlEncodedForm(value): + body = try converter.setOptionalRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.challengeDecline.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeDecline.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 404: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeDecline.Output.NotFound.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.NotFound.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .notFound(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Cancel a challenge + /// + /// Cancel a challenge you sent, or aborts the game if the challenge was accepted, but the game was not yet played. + /// Note that the ID of a game is the same as the ID of the challenge that created it. + /// Works for user challenges and open challenges alike. + /// + /// + /// - Remark: HTTP `POST /api/challenge/{challengeId}/cancel`. + /// - Remark: Generated from `#/paths//api/challenge/{challengeId}/cancel/post(challengeCancel)`. + internal func challengeCancel(_ input: Operations.challengeCancel.Input) async throws -> Operations.challengeCancel.Output { + try await client.send( + input: input, + forOperation: Operations.challengeCancel.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/challenge/{}/cancel", + parameters: [ + input.path.challengeId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "opponentToken", + value: input.query.opponentToken + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.challengeCancel.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeCancel.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 404: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeCancel.Output.NotFound.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.NotFound.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .notFound(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Challenge the AI + /// + /// Start a game with Lichess AI. + /// You will be notified on the [event stream](#operation/apiStreamEvent) that a new game has started. + /// + /// + /// - Remark: HTTP `POST /api/challenge/ai`. + /// - Remark: Generated from `#/paths//api/challenge/ai/post(challengeAi)`. + internal func challengeAi(_ input: Operations.challengeAi.Input) async throws -> Operations.challengeAi.Output { + try await client.send( + input: input, + forOperation: Operations.challengeAi.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/challenge/ai", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 201: + let headers: Operations.challengeAi.Output.Created.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeAi.Output.Created.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.GameJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .created(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeAi.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Open-ended challenge + /// + /// Create a challenge that any 2 players can join. + /// Share the URL of the challenge. the first 2 players to click it will be paired for a game. + /// The response body also contains `whiteUrl` and `blackUrl`. + /// You can control which color each player gets by giving them these URLs, + /// instead of the main challenge URL. + /// Open challenges expire after 24h. + /// If the challenge creation is [authenticated with OAuth2](#section/Introduction/Authentication), + /// then you can use the [challenge cancel endpoint](#operation/challengeCancel) to cancel it. + /// To directly pair 2 known players, use [this endpoint](#operation/bulkPairingList) instead. + /// + /// + /// - Remark: HTTP `POST /api/challenge/open`. + /// - Remark: Generated from `#/paths//api/challenge/open/post(challengeOpen)`. + internal func challengeOpen(_ input: Operations.challengeOpen.Input) async throws -> Operations.challengeOpen.Output { + try await client.send( + input: input, + forOperation: Operations.challengeOpen.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/challenge/open", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.challengeOpen.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeOpen.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.ChallengeOpenJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeOpen.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Start clocks of a game + /// + /// Start the clocks of a game immediately, even if a player has not yet made a move. + /// Requires the OAuth tokens of both players with `challenge:write` scope. + /// If the clocks have already started, the call will have no effect. + /// + /// + /// - Remark: HTTP `POST /api/challenge/{gameId}/start-clocks`. + /// - Remark: Generated from `#/paths//api/challenge/{gameId}/start-clocks/post(challengeStartClocks)`. + internal func challengeStartClocks(_ input: Operations.challengeStartClocks.Input) async throws -> Operations.challengeStartClocks.Output { + try await client.send( + input: input, + forOperation: Operations.challengeStartClocks.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/challenge/{}/start-clocks", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "token1", + value: input.query.token1 + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "token2", + value: input.query.token2 + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.challengeStartClocks.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.challengeStartClocks.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// View your bulk pairings + /// + /// Get a list of bulk pairings you created. + /// + /// + /// - Remark: HTTP `GET /api/bulk-pairing`. + /// - Remark: Generated from `#/paths//api/bulk-pairing/get(bulkPairingList)`. + internal func bulkPairingList(_ input: Operations.bulkPairingList.Input) async throws -> Operations.bulkPairingList.Output { + try await client.send( + input: input, + forOperation: Operations.bulkPairingList.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bulk-pairing", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.bulkPairingList.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.bulkPairingList.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + [Components.Schemas.BulkPairing].self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Create a bulk pairing + /// + /// Schedule many games at once, up to 24h in advance. + /// OAuth tokens are required for all paired players, with the `challenge:write` scope. + /// You can schedule up to 500 games every 10 minutes. [Contact us](mailto:contact@lichess.org) if you need higher limits. + /// If games have a real-time clock, each player must have only one pairing. + /// For correspondence games, players can have multiple pairings within the same bulk. + /// The entire bulk is rejected if: + /// - a token is missing + /// - a token is present more than once (except in correspondence) + /// - a token lacks the `challenge:write` scope + /// - a player account is closed + /// - a player is paired more than once (except in correspondence) + /// - a bulk is already scheduled to start at the same time with the same player + /// - you have 20 scheduled bulks + /// - you have 1000 scheduled games + /// Partial bulks are never created. Either it all fails, or it all succeeds. + /// When it fails, it does so with an error message explaining the issue. + /// Failed bulks are not counted in the rate limiting, they are free. + /// Fix the issues, manually or programmatically, then retry to schedule the bulk. + /// A successful bulk creation returns a JSON bulk document. Its ID can be used for further operations. + /// + /// + /// - Remark: HTTP `POST /api/bulk-pairing`. + /// - Remark: Generated from `#/paths//api/bulk-pairing/post(bulkPairingCreate)`. + internal func bulkPairingCreate(_ input: Operations.bulkPairingCreate.Input) async throws -> Operations.bulkPairingCreate.Output { + try await client.send( + input: input, + forOperation: Operations.bulkPairingCreate.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bulk-pairing", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.bulkPairingCreate.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.bulkPairingCreate.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.BulkPairing.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.bulkPairingCreate.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Manually start clocks + /// + /// Immediately start all clocks of the games of a bulk pairing. + /// This overrides the `startClocksAt` value of an existing bulk pairing. + /// If the games have not yet been created (`bulk.pairAt` is in the future), then this does nothing. + /// If the clocks have already started (`bulk.startClocksAt` is in the past), then this does nothing. + /// + /// + /// - Remark: HTTP `POST /api/bulk-pairing/{id}/start-clocks`. + /// - Remark: Generated from `#/paths//api/bulk-pairing/{id}/start-clocks/post(bulkPairingStartClocks)`. + internal func bulkPairingStartClocks(_ input: Operations.bulkPairingStartClocks.Input) async throws -> Operations.bulkPairingStartClocks.Output { + try await client.send( + input: input, + forOperation: Operations.bulkPairingStartClocks.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bulk-pairing/{}/start-clocks", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.bulkPairingStartClocks.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.bulkPairingStartClocks.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 404: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.bulkPairingStartClocks.Output.NotFound.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.NotFound.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .notFound(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Show a bulk pairing + /// + /// Get a single bulk pairing by its ID. + /// + /// + /// - Remark: HTTP `GET /api/bulk-pairing/{id}`. + /// - Remark: Generated from `#/paths//api/bulk-pairing/{id}/get(bulkPairingGet)`. + internal func bulkPairingGet(_ input: Operations.bulkPairingGet.Input) async throws -> Operations.bulkPairingGet.Output { + try await client.send( + input: input, + forOperation: Operations.bulkPairingGet.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bulk-pairing/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.bulkPairingGet.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.bulkPairingGet.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.BulkPairing.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 404: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.bulkPairingGet.Output.NotFound.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.NotFound.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .notFound(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Cancel a bulk pairing + /// + /// Cancel and delete a bulk pairing that is scheduled in the future. + /// If the games have already been created, then this does nothing. + /// Canceling a bulk pairing does not refund the rate limit cost of that bulk pairing. + /// + /// + /// - Remark: HTTP `DELETE /api/bulk-pairing/{id}`. + /// - Remark: Generated from `#/paths//api/bulk-pairing/{id}/delete(bulkPairingDelete)`. + internal func bulkPairingDelete(_ input: Operations.bulkPairingDelete.Input) async throws -> Operations.bulkPairingDelete.Output { + try await client.send( + input: input, + forOperation: Operations.bulkPairingDelete.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/bulk-pairing/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .delete + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.bulkPairingDelete.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.bulkPairingDelete.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 404: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.bulkPairingDelete.Output.NotFound.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.NotFound.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .notFound(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Add time to the opponent clock + /// + /// Add seconds to the opponent's clock. Can be used to create games with time odds. + /// + /// + /// - Remark: HTTP `POST /api/round/{gameId}/add-time/{seconds}`. + /// - Remark: Generated from `#/paths//api/round/{gameId}/add-time/{seconds}/post(roundAddTime)`. + internal func roundAddTime(_ input: Operations.roundAddTime.Input) async throws -> Operations.roundAddTime.Output { + try await client.send( + input: input, + forOperation: Operations.roundAddTime.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/round/{}/add-time/{}", + parameters: [ + input.path.gameId, + input.path.seconds + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.roundAddTime.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.roundAddTime.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Admin challenge tokens + /// + /// **This endpoint can only be used by Lichess administrators. It will not work if you do not have the appropriate permissions.** Tournament organizers should instead use [OAuth](#tag/OAuth) to obtain `challenge:write` tokens from users in order to perform bulk pairing.* + /// Create and obtain `challenge:write` tokens for multiple users. + /// If a similar token already exists for a user, it is reused. This endpoint is idempotent. + /// + /// + /// - Remark: HTTP `POST /api/token/admin-challenge`. + /// - Remark: Generated from `#/paths//api/token/admin-challenge/post(adminChallengeTokens)`. + internal func adminChallengeTokens(_ input: Operations.adminChallengeTokens.Input) async throws -> Operations.adminChallengeTokens.Output { + try await client.send( + input: input, + forOperation: Operations.adminChallengeTokens.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/token/admin-challenge", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.adminChallengeTokens.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.adminChallengeTokens.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + OpenAPIRuntime.OpenAPIValueContainer.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.adminChallengeTokens.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Send a private message + /// + /// Send a private message to another player. + /// + /// + /// - Remark: HTTP `POST /inbox/{username}`. + /// - Remark: Generated from `#/paths//inbox/{username}/post(inboxUsername)`. + internal func inboxUsername(_ input: Operations.inboxUsername.Input) async throws -> Operations.inboxUsername.Output { + try await client.send( + input: input, + forOperation: Operations.inboxUsername.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/inbox/{}", + parameters: [ + input.path.username + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.inboxUsername.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + case 400: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.inboxUsername.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas._Error.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get cloud evaluation of a position. + /// + /// Get the cached evaluation of a position, if available. + /// Opening positions have more chances of being available. There are about 15 million positions in the database. + /// Up to 5 variations may be available. Variants are supported. + /// Use this endpoint to fetch a few positions here and there. + /// If you want to download a lot of positions, [get the full list](https://database.lichess.org/#evals) from our exported database. + /// + /// + /// - Remark: HTTP `GET /api/cloud-eval`. + /// - Remark: Generated from `#/paths//api/cloud-eval/get(apiCloudEval)`. + internal func apiCloudEval(_ input: Operations.apiCloudEval.Input) async throws -> Operations.apiCloudEval.Output { + try await client.send( + input: input, + forOperation: Operations.apiCloudEval.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/cloud-eval", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "fen", + value: input.query.fen + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "multiPv", + value: input.query.multiPv + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "variant", + value: input.query.variant + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiCloudEval.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiCloudEval.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + OpenAPIRuntime.OpenAPIValueContainer.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// List external engines + /// + /// Lists all external engines that have been registered for the user, + /// and the credentials required to use them. + /// + /// + /// - Remark: HTTP `GET /api/external-engine`. + /// - Remark: Generated from `#/paths//api/external-engine/get(apiExternalEngineList)`. + internal func apiExternalEngineList(_ input: Operations.apiExternalEngineList.Input) async throws -> Operations.apiExternalEngineList.Output { + try await client.send( + input: input, + forOperation: Operations.apiExternalEngineList.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/external-engine", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiExternalEngineList.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiExternalEngineList.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + [Components.Schemas.ExternalEngine].self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Create external engine + /// + /// Registers a new external engine for the user. It can then be selected + /// and used on the analysis board. + /// After registering, the provider should start waiting for analyis requests. + /// + /// + /// - Remark: HTTP `POST /api/external-engine`. + /// - Remark: Generated from `#/paths//api/external-engine/post(apiExternalEngineCreate)`. + internal func apiExternalEngineCreate(_ input: Operations.apiExternalEngineCreate.Input) async throws -> Operations.apiExternalEngineCreate.Output { + try await client.send( + input: input, + forOperation: Operations.apiExternalEngineCreate.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/external-engine", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .json(value): + body = try converter.setRequiredRequestBodyAsJSON( + value, + headerFields: &request.headerFields, + contentType: "application/json; charset=utf-8" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiExternalEngineCreate.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiExternalEngineCreate.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.ExternalEngine.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Get external engine + /// + /// Get properties and credentials of an external engine. + /// + /// + /// - Remark: HTTP `GET /api/external-engine/{id}`. + /// - Remark: Generated from `#/paths//api/external-engine/{id}/get(apiExternalEngineGet)`. + internal func apiExternalEngineGet(_ input: Operations.apiExternalEngineGet.Input) async throws -> Operations.apiExternalEngineGet.Output { + try await client.send( + input: input, + forOperation: Operations.apiExternalEngineGet.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/external-engine/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiExternalEngineGet.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiExternalEngineGet.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.ExternalEngine.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Update external engine + /// + /// Updates the properties of an external engine. + /// + /// + /// - Remark: HTTP `PUT /api/external-engine/{id}`. + /// - Remark: Generated from `#/paths//api/external-engine/{id}/put(apiExternalEnginePut)`. + internal func apiExternalEnginePut(_ input: Operations.apiExternalEnginePut.Input) async throws -> Operations.apiExternalEnginePut.Output { + try await client.send( + input: input, + forOperation: Operations.apiExternalEnginePut.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/external-engine/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .put + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .json(value): + body = try converter.setRequiredRequestBodyAsJSON( + value, + headerFields: &request.headerFields, + contentType: "application/json; charset=utf-8" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiExternalEnginePut.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiExternalEnginePut.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.ExternalEngine.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Delete external engine + /// + /// Unregisters an external engine. + /// + /// + /// - Remark: HTTP `DELETE /api/external-engine/{id}`. + /// - Remark: Generated from `#/paths//api/external-engine/{id}/delete(apiExternalEngineDelete)`. + internal func apiExternalEngineDelete(_ input: Operations.apiExternalEngineDelete.Input) async throws -> Operations.apiExternalEngineDelete.Output { + try await client.send( + input: input, + forOperation: Operations.apiExternalEngineDelete.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/external-engine/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .delete + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiExternalEngineDelete.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.Ok.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Analyse with external engine + /// + /// **Endpoint: `https://engine.lichess.ovh/api/external-engine/{id}/analyse`** + /// Request analysis from an external engine. + /// Response content is streamed as [newline delimited JSON](#section/Introduction/Streaming-with-ND-JSON). + /// The properties are based on the [UCI specification](https://backscattering.de/chess/uci/#engine). + /// Analysis stops when the client goes away, the requested limit + /// is reached, or the provider goes away. + /// + /// + /// - Remark: HTTP `POST /api/external-engine/{id}/analyse`. + /// - Remark: Generated from `#/paths//api/external-engine/{id}/analyse/post(apiExternalEngineAnalyse)`. + internal func apiExternalEngineAnalyse(_ input: Operations.apiExternalEngineAnalyse.Input) async throws -> Operations.apiExternalEngineAnalyse.Output { + try await client.send( + input: input, + forOperation: Operations.apiExternalEngineAnalyse.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/external-engine/{}/analyse", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .json(value): + body = try converter.setRequiredRequestBodyAsJSON( + value, + headerFields: &request.headerFields, + contentType: "application/json; charset=utf-8" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiExternalEngineAnalyse.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiExternalEngineAnalyse.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-ndjson" + ] + ) + switch chosenContentType { + case "application/x-ndjson": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_ndjson(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Acquire analysis request + /// + /// **Endpoint: `https://engine.lichess.ovh/api/external-engine/work`** + /// Wait for an analysis requests to any of the external engines that + /// have been registered with the given `secret`. + /// Uses long polling. + /// After acquiring a request, the provider should immediately + /// [start streaming the results](#tag/External-engine/operation/apiExternalEngineSubmit). + /// + /// + /// - Remark: HTTP `POST /api/external-engine/work`. + /// - Remark: Generated from `#/paths//api/external-engine/work/post(apiExternalEngineAcquire)`. + internal func apiExternalEngineAcquire(_ input: Operations.apiExternalEngineAcquire.Input) async throws -> Operations.apiExternalEngineAcquire.Output { + try await client.send( + input: input, + forOperation: Operations.apiExternalEngineAcquire.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/external-engine/work", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .json(value): + body = try converter.setRequiredRequestBodyAsJSON( + value, + headerFields: &request.headerFields, + contentType: "application/json; charset=utf-8" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiExternalEngineAcquire.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiExternalEngineAcquire.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Operations.apiExternalEngineAcquire.Output.Ok.Body.jsonPayload.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 204: + let headers: Operations.apiExternalEngineAcquire.Output.NoContent.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + return .noContent(.init(headers: headers)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Answer analysis request + /// + /// **Endpoint: `https://engine.lichess.ovh/api/external-engine/work/{id}`** + /// Submit a stream of analysis as [UCI output](https://backscattering.de/chess/uci/#engine-info). + /// * The engine should always be in `UCI_Chess960` mode. + /// * `UCI_AnalyseMode` enabled if available. + /// * It produces `info` with at least: + /// - `depth` + /// - `multipv` (between 1 and 5) + /// - `score` + /// - `nodes` + /// - `time` + /// - `pv` + /// The server may close the connection at any time, indicating that + /// the requester has gone away and analysis should be stopped. + /// + /// + /// - Remark: HTTP `POST /api/external-engine/work/{id}`. + /// - Remark: Generated from `#/paths//api/external-engine/work/{id}/post(apiExternalEngineSubmit)`. + internal func apiExternalEngineSubmit(_ input: Operations.apiExternalEngineSubmit.Input) async throws -> Operations.apiExternalEngineSubmit.Output { + try await client.send( + input: input, + forOperation: Operations.apiExternalEngineSubmit.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/external-engine/work/{}", + parameters: [ + input.path.id + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .plainText(value): + body = try converter.setRequiredRequestBodyAsBinary( + value, + headerFields: &request.headerFields, + contentType: "text/plain" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiExternalEngineSubmit.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + return .ok(.init(headers: headers)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Request authorization code + /// + /// OAuth2 authorization endpoint. + /// Start the OAuth2 Authorization Code Flow with PKCE by securely + /// generating two random strings unique to each authorization + /// request: + /// * `code_verifier` + /// * `state` + /// Store these in session storage. Make sure not to reveal `code_verifier` + /// to eavesdroppers. Do not show it in URLs, do not abuse `state` to store + /// it, do not send it over insecure connections. However it is fine if + /// the user themselves can extract `code_verifier`, which will always be + /// possible for fully client-side apps. + /// Then send the user to this endpoint. They will be prompted to grant + /// authorization and then be redirected back to the given `redirect_uri`. + /// If the authorization failed, the following query string parameters will + /// be appended to the redirection: + /// * `error`, in particular with value `access_denied` if the user + /// cancelled authorization + /// * `error_description` to aid debugging + /// * `state`, exactly as passed in the `state` parameter + /// If the authorization succeeded, the following query string parameters + /// will be appended to the redirection: + /// * `code`, containing a fresh short-lived authorization code + /// * `state`, exactly as passed in the `state` parameter + /// Next, to defend against cross site request forgery, check that the + /// returned `state` matches the `state` you originally generated. + /// Finally, continue by using the authorization code to + /// [obtain an access token](#operation/apiToken). + /// + /// + /// - Remark: HTTP `GET /oauth`. + /// - Remark: Generated from `#/paths//oauth/get(oauth)`. + internal func oauth(_ input: Operations.oauth.Input) async throws -> Operations.oauth.Output { + try await client.send( + input: input, + forOperation: Operations.oauth.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/oauth", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "response_type", + value: input.query.response_type + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "client_id", + value: input.query.client_id + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "redirect_uri", + value: input.query.redirect_uri + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "code_challenge_method", + value: input.query.code_challenge_method + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "code_challenge", + value: input.query.code_challenge + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "scope", + value: input.query.scope + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "username", + value: input.query.username + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "state", + value: input.query.state + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + return .ok(.init()) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Obtain access token + /// + /// OAuth2 token endpoint. Exchanges an authorization code for an access token. + /// + /// + /// - Remark: HTTP `POST /api/token`. + /// - Remark: Generated from `#/paths//api/token/post(apiToken)`. + internal func apiToken(_ input: Operations.apiToken.Input) async throws -> Operations.apiToken.Output { + try await client.send( + input: input, + forOperation: Operations.apiToken.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/token", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .urlEncodedForm(value): + body = try converter.setRequiredRequestBodyAsURLEncodedForm( + value, + headerFields: &request.headerFields, + contentType: "application/x-www-form-urlencoded" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.apiToken.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiToken.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + OpenAPIRuntime.OpenAPIValueContainer.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + case 400: + let headers: Operations.apiToken.Output.BadRequest.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.apiToken.Output.BadRequest.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.OAuthError.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .badRequest(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Revoke access token + /// + /// Revokes the access token sent as Bearer for this request. + /// + /// - Remark: HTTP `DELETE /api/token`. + /// - Remark: Generated from `#/paths//api/token/delete(apiTokenDelete)`. + internal func apiTokenDelete(_ input: Operations.apiTokenDelete.Input) async throws -> Operations.apiTokenDelete.Output { + try await client.send( + input: input, + forOperation: Operations.apiTokenDelete.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/token", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .delete + ) + suppressMutabilityWarning(&request) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 204: + let headers: Operations.apiTokenDelete.Output.NoContent.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + return .noContent(.init(headers: headers)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Test multiple OAuth tokens + /// + /// For up to 1000 OAuth tokens, + /// returns their associated user ID and scopes, + /// or `null` if the token is invalid. + /// The method is `POST` so a longer list of tokens can be sent in the request body. + /// + /// + /// - Remark: HTTP `POST /api/token/test`. + /// - Remark: Generated from `#/paths//api/token/test/post(tokenTest)`. + internal func tokenTest(_ input: Operations.tokenTest.Input) async throws -> Operations.tokenTest.Output { + try await client.send( + input: input, + forOperation: Operations.tokenTest.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/api/token/test", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .post + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + let body: OpenAPIRuntime.HTTPBody? + switch input.body { + case let .plainText(value): + body = try converter.setRequiredRequestBodyAsBinary( + value, + headerFields: &request.headerFields, + contentType: "text/plain" + ) + } + return (request, body) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.tokenTest.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Operations.tokenTest.Output.Ok.Body.jsonPayload.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init(body: body)) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Masters database + /// + /// **Endpoint: <https://explorer.lichess.ovh/masters>** + /// Example: `curl https://explorer.lichess.ovh/masters?play=d2d4,d7d5,c2c4,c7c6,c4d5` + /// + /// + /// - Remark: HTTP `GET /masters`. + /// - Remark: Generated from `#/paths//masters/get(openingExplorerMaster)`. + internal func openingExplorerMaster(_ input: Operations.openingExplorerMaster.Input) async throws -> Operations.openingExplorerMaster.Output { + try await client.send( + input: input, + forOperation: Operations.openingExplorerMaster.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/masters", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "fen", + value: input.query.fen + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "play", + value: input.query.play + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "since", + value: input.query.since + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "until", + value: input.query.until + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "moves", + value: input.query.moves + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "topGames", + value: input.query.topGames + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.openingExplorerMaster.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.openingExplorerMaster.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.OpeningExplorerJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Lichess games + /// + /// **Endpoint: <https://explorer.lichess.ovh/lichess>** + /// Games sampled from all Lichess players. + /// Example: `curl https://explorer.lichess.ovh/lichess?variant=standard&speeds=blitz,rapid,classical&ratings=2200,2500&fen=rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR%20w%20KQkq%20-%200%201` + /// + /// + /// - Remark: HTTP `GET /lichess`. + /// - Remark: Generated from `#/paths//lichess/get(openingExplorerLichess)`. + internal func openingExplorerLichess(_ input: Operations.openingExplorerLichess.Input) async throws -> Operations.openingExplorerLichess.Output { + try await client.send( + input: input, + forOperation: Operations.openingExplorerLichess.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/lichess", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "variant", + value: input.query.variant + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "fen", + value: input.query.fen + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "play", + value: input.query.play + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "speeds", + value: input.query.speeds + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "ratings", + value: input.query.ratings + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "since", + value: input.query.since + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "until", + value: input.query.until + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "moves", + value: input.query.moves + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "topGames", + value: input.query.topGames + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "recentGames", + value: input.query.recentGames + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "history", + value: input.query.history + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.openingExplorerLichess.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.openingExplorerLichess.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.OpeningExplorerJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Player games + /// + /// **Endpoint: <https://explorer.lichess.ovh/player>** + /// Games of a Lichess player. + /// Responds with a stream of [newline delimited JSON](#section/Introduction/Streaming-with-ND-JSON). Will start indexing + /// on demand, immediately respond with the current results, and stream + /// more updates until indexing is complete. The stream is throttled + /// and deduplicated. Empty lines may be sent to avoid timeouts. + /// Will index new games at most once per minute, and revisit previously + /// ongoing games at most once every day. + /// Example: `curl https://explorer.lichess.ovh/player?player=revoof&color=white&play=d2d4,d7d5&recentGames=1` + /// + /// + /// - Remark: HTTP `GET /player`. + /// - Remark: Generated from `#/paths//player/get(openingExplorerPlayer)`. + internal func openingExplorerPlayer(_ input: Operations.openingExplorerPlayer.Input) async throws -> Operations.openingExplorerPlayer.Output { + try await client.send( + input: input, + forOperation: Operations.openingExplorerPlayer.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/player", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "player", + value: input.query.player + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "variant", + value: input.query.variant + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "fen", + value: input.query.fen + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "play", + value: input.query.play + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "speeds", + value: input.query.speeds + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "modes", + value: input.query.modes + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "since", + value: input.query.since + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "until", + value: input.query.until + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "moves", + value: input.query.moves + ) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "recentGames", + value: input.query.recentGames + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.openingExplorerPlayer.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.openingExplorerPlayer.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/nd-json" + ] + ) + switch chosenContentType { + case "application/nd-json": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_nd_hyphen_json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// OTB master game + /// + /// **Endpoint: `https://explorer.lichess.ovh/masters/pgn/{gameId}`** + /// Example: `curl https://explorer.lichess.ovh/masters/pgn/aAbqI4ey` + /// + /// + /// - Remark: HTTP `GET /master/pgn/{gameId}`. + /// - Remark: Generated from `#/paths//master/pgn/{gameId}/get(openingExplorerMasterGame)`. + internal func openingExplorerMasterGame(_ input: Operations.openingExplorerMasterGame.Input) async throws -> Operations.openingExplorerMasterGame.Output { + try await client.send( + input: input, + forOperation: Operations.openingExplorerMasterGame.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/master/pgn/{}", + parameters: [ + input.path.gameId + ] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.openingExplorerMasterGame.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.openingExplorerMasterGame.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/x-chess-pgn" + ] + ) + switch chosenContentType { + case "application/x-chess-pgn": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .application_x_hyphen_chess_hyphen_pgn(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Tablebase lookup + /// + /// **Endpoint: <https://tablebase.lichess.ovh>** + /// Example: `curl http://tablebase.lichess.ovh/standard?fen=4k3/6KP/8/8/8/8/7p/8_w_-_-_0_1` + /// + /// + /// - Remark: HTTP `GET /standard`. + /// - Remark: Generated from `#/paths//standard/get(tablebaseStandard)`. + internal func tablebaseStandard(_ input: Operations.tablebaseStandard.Input) async throws -> Operations.tablebaseStandard.Output { + try await client.send( + input: input, + forOperation: Operations.tablebaseStandard.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/standard", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + try converter.setQueryItemAsURI( + in: &request, + style: .form, + explode: true, + name: "fen", + value: input.query.fen + ) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.tablebaseStandard.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.tablebaseStandard.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "application/json" + ] + ) + switch chosenContentType { + case "application/json": + body = try await converter.getResponseBodyAsJSON( + Components.Schemas.TablebaseJson.self, + from: responseBody, + transforming: { value in + .json(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Tablebase lookup for Atomic chess + /// + /// **Endpoint: <https://tablebase.lichess.ovh>** + /// + /// + /// - Remark: HTTP `GET /atomic`. + /// - Remark: Generated from `#/paths//atomic/get(tablebaseAtomic)`. + internal func tablebaseAtomic(_ input: Operations.tablebaseAtomic.Input) async throws -> Operations.tablebaseAtomic.Output { + try await client.send( + input: input, + forOperation: Operations.tablebaseAtomic.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/atomic", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.tablebaseAtomic.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.tablebaseAtomic.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "text/plain" + ] + ) + switch chosenContentType { + case "text/plain": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .plainText(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } + /// Tablebase lookup for Antichess + /// + /// **Endpoint: <https://tablebase.lichess.ovh>** + /// + /// + /// - Remark: HTTP `GET /antichess`. + /// - Remark: Generated from `#/paths//antichess/get(antichessAtomic)`. + internal func antichessAtomic(_ input: Operations.antichessAtomic.Input) async throws -> Operations.antichessAtomic.Output { + try await client.send( + input: input, + forOperation: Operations.antichessAtomic.id, + serializer: { input in + let path = try converter.renderedPath( + template: "/antichess", + parameters: [] + ) + var request: HTTPTypes.HTTPRequest = .init( + soar_path: path, + method: .get + ) + suppressMutabilityWarning(&request) + converter.setAcceptHeader( + in: &request.headerFields, + contentTypes: input.headers.accept + ) + return (request, nil) + }, + deserializer: { response, responseBody in + switch response.status.code { + case 200: + let headers: Operations.antichessAtomic.Output.Ok.Headers = .init(Access_hyphen_Control_hyphen_Allow_hyphen_Origin: try converter.getOptionalHeaderFieldAsURI( + in: response.headerFields, + name: "Access-Control-Allow-Origin", + as: Swift.String.self + )) + let contentType = converter.extractContentTypeIfPresent(in: response.headerFields) + let body: Operations.antichessAtomic.Output.Ok.Body + let chosenContentType = try converter.bestContentType( + received: contentType, + options: [ + "text/plain" + ] + ) + switch chosenContentType { + case "text/plain": + body = try converter.getResponseBodyAsBinary( + OpenAPIRuntime.HTTPBody.self, + from: responseBody, + transforming: { value in + .plainText(value) + } + ) + default: + preconditionFailure("bestContentType chose an invalid content type.") + } + return .ok(.init( + headers: headers, + body: body + )) + default: + return .undocumented( + statusCode: response.status.code, + .init( + headerFields: response.headerFields, + body: responseBody + ) + ) + } + } + ) + } +} |