//------------------------------------------------------------------------------
//        This code was generated by myriad.
//        Changes to this file will be lost when the code is regenerated.
//------------------------------------------------------------------------------





namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module PureGymApi =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IPureGymApi =
        { new IPureGymApi with
            member _.GetGyms (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri (("v1/gyms/"), System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type Gym list"
                             )
                         | jsonNode -> jsonNode)

                    return
                        jsonNode.AsArray ()
                        |> Seq.map (fun elt ->
                            (match elt with
                             | null ->
                                 raise (
                                     System.ArgumentNullException
                                         "Expected element of array (element type Gym) to be non-null, but found a null element"
                                 )
                             | elt -> Gym.jsonParse elt)
                        )
                        |> List.ofSeq
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetGymAttendance (gymId : int, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri (
                                "v1/gyms/{gym_id}/attendance"
                                    .Replace ("{gym_id}", gymId.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type GymAttendance"
                             )
                         | jsonNode -> jsonNode)

                    return GymAttendance.jsonParse jsonNode
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetGymAttendance' (gymId : int, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri (
                                "v1/gyms/{gym_id}/attendance"
                                    .Replace ("{gym_id}", gymId.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type GymAttendance"
                             )
                         | jsonNode -> jsonNode)

                    return GymAttendance.jsonParse jsonNode
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetMember (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("v1/member", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type Member"
                             )
                         | jsonNode -> jsonNode)

                    return Member.jsonParse jsonNode
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetGym (gym : int, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri (
                                "v1/gyms/{gym}".Replace ("{gym}", gym.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type Gym"
                             )
                         | jsonNode -> jsonNode)

                    return Gym.jsonParse jsonNode
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetMemberActivity (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("v1/member/activity", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type MemberActivityDto"
                             )
                         | jsonNode -> jsonNode)

                    return MemberActivityDto.jsonParse jsonNode
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetUrl (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("some/url", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type UriThing"
                             )
                         | jsonNode -> jsonNode)

                    return UriThing.jsonParse jsonNode
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.PostStringToString (foo : Map<string, string> option, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("some/url", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams =
                        new System.Net.Http.StringContent (
                            foo
                            |> (fun field ->
                                match field with
                                | None -> None
                                | Some field ->
                                    (field
                                     |> (fun field ->
                                         let ret = System.Text.Json.Nodes.JsonObject ()

                                         for (KeyValue (key, value)) in field do
                                             let key = key.ToString ()

                                             ret.Add (
                                                 key,
                                                 (fun field ->
                                                     let field =
                                                         System.Text.Json.Nodes.JsonValue.Create<string> field

                                                     (match field with
                                                      | null ->
                                                          raise (
                                                              System.ArgumentNullException
                                                                  "Expected type string to be non-null, but received a null value when serialising"
                                                          )
                                                      | field -> field)
                                                 )
                                                     value
                                             )

                                         ret
                                     ))
                                    :> System.Text.Json.Nodes.JsonNode
                                    |> Some
                            )
                            |> (fun node ->
                                match node with
                                | None -> "null"
                                | Some node -> node.ToJsonString ()
                            ),
                            null,
                            "application/json"
                        )

                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode = jsonNode |> Option.ofObj

                    return
                        match jsonNode with
                        | None -> None
                        | Some v ->
                            v.AsObject ()
                            |> Seq.map (fun kvp ->
                                let key = (kvp.Key)
                                let value = kvp.Value

                                key,
                                (match value with
                                 | null ->
                                     raise (
                                         System.ArgumentNullException
                                             "Expected dictionary value of type string to be non-null, but it was null"
                                     )
                                 | value -> value.AsValue().GetValue<System.String> ())
                            )
                            |> Map.ofSeq
                            |> Some
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetSessions (fromDate : DateOnly, toDate : DateOnly, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri (
                                ("/v2/gymSessions/member"
                                 + (if "/v2/gymSessions/member".IndexOf (char 63) >= 0 then
                                        "&"
                                    else
                                        "?")
                                 + "fromDate="
                                 + ((fromDate.ToString "yyyy-MM-dd") |> System.Uri.EscapeDataString)
                                 + "&toDate="
                                 + ((toDate.ToString "yyyy-MM-dd") |> System.Uri.EscapeDataString)),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type Sessions"
                             )
                         | jsonNode -> jsonNode)

                    return Sessions.jsonParse jsonNode
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetSessionsWithQuery (fromDate : DateOnly, toDate : DateOnly, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri (
                                ("/v2/gymSessions/member?foo=1"
                                 + (if "/v2/gymSessions/member?foo=1".IndexOf (char 63) >= 0 then
                                        "&"
                                    else
                                        "?")
                                 + "fromDate="
                                 + ((fromDate.ToString "yyyy-MM-dd") |> System.Uri.EscapeDataString)
                                 + "&toDate="
                                 + ((toDate.ToString "yyyy-MM-dd") |> System.Uri.EscapeDataString)),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type Sessions"
                             )
                         | jsonNode -> jsonNode)

                    return Sessions.jsonParse jsonNode
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.CreateUserString (user : string, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("users/new", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams = new System.Net.Http.StringContent (user)
                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.CreateUserStream (user : System.IO.Stream, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("users/new", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams = new System.Net.Http.StreamContent (user)
                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
                    return responseStream
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.CreateUserByteArr (user : byte[], ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("users/new", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams = new System.Net.Http.ByteArrayContent (user)
                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
                    return responseStream
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.CreateUserByteArr' (user : array<byte>, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("users/new", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams = new System.Net.Http.ByteArrayContent (user)
                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
                    return responseStream
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.CreateUserByteArr'' (user : byte array, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("users/new", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams = new System.Net.Http.ByteArrayContent (user)
                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
                    return responseStream
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.CreateUserSerialisedBody (user : PureGym.Member, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("users/new", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams =
                        new System.Net.Http.StringContent (
                            user |> PureGym.Member.toJsonNode |> (fun node -> node.ToJsonString ()),
                            null,
                            "application/json"
                        )

                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.CreateUserSerialisedUrlBody (user : Uri, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("users/new", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams =
                        new System.Net.Http.StringContent (
                            user
                            |> (fun field ->
                                let field = System.Text.Json.Nodes.JsonValue.Create<Uri> field

                                (match field with
                                 | null ->
                                     raise (
                                         System.ArgumentNullException
                                             "Expected type URI to be non-null, but received a null value when serialising"
                                     )
                                 | field -> field)
                            )
                            |> (fun node -> node.ToJsonString ()),
                            null,
                            "application/json"
                        )

                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.CreateUserSerialisedIntBody (user : int, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("users/new", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams =
                        new System.Net.Http.StringContent (
                            user
                            |> (fun field ->
                                let field = System.Text.Json.Nodes.JsonValue.Create<int> field

                                (match field with
                                 | null ->
                                     raise (
                                         System.ArgumentNullException
                                             "Expected type int32 to be non-null, but received a null value when serialising"
                                     )
                                 | field -> field)
                            )
                            |> (fun node -> node.ToJsonString ()),
                            null,
                            "application/json"
                        )

                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.CreateUserHttpContent (user : System.Net.Http.HttpContent, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("users/new", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    do httpMessage.Content <- user
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetPathParam (parameter : string, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri (
                                "endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetStream (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
                    return responseStream
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetStream' (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
                    return responseStream
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetStream'' (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
                    return responseStream
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetResponseMessage (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    return response
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetResponseMessage' (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    return response
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetResponseMessage'' (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    return response
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetResponseMessage''' (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    return response
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetResponse (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type Response<MemberActivityDto>"
                             )
                         | jsonNode -> jsonNode)

                    return
                        new RestEase.Response<_> (
                            responseString,
                            response,
                            (fun () -> (MemberActivityDto.jsonParse jsonNode))
                        )
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetResponse' (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type RestEase.Response<MemberActivityDto>"
                             )
                         | jsonNode -> jsonNode)

                    return
                        new RestEase.Response<_> (
                            responseString,
                            response,
                            (fun () -> (MemberActivityDto.jsonParse jsonNode))
                        )
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetResponse'' (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type Response<MemberActivityDto>"
                             )
                         | jsonNode -> jsonNode)

                    return
                        new RestEase.Response<_> (
                            responseString,
                            response,
                            (fun () -> (MemberActivityDto.jsonParse jsonNode))
                        )
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetResponse''' (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask

                    let! jsonNode =
                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
                        |> Async.AwaitTask

                    let jsonNode =
                        (match jsonNode with
                         | null ->
                             raise (
                                 System.ArgumentNullException
                                     "Response from server was the JSON null object; expected a non-nullable type RestEase.Response<MemberActivityDto>"
                             )
                         | jsonNode -> jsonNode)

                    return
                        new RestEase.Response<_> (
                            responseString,
                            response,
                            (fun () -> (MemberActivityDto.jsonParse jsonNode))
                        )
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetWithAnyReturnCode (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    return response
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))

            member _.GetWithoutAnyReturnCode (ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null -> System.Uri "https://whatnot.com/"
                             | v -> v),
                            System.Uri ("endpoint", System.UriKind.Relative)
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    return response
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module internal ApiWithoutBaseAddress =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IApiWithoutBaseAddress =
        { new IApiWithoutBaseAddress with
            member _.GetPathParam (parameter : string, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null ->
                                 raise (
                                     System.ArgumentNullException (
                                         nameof (client.BaseAddress),
                                         "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
                                     )
                                 )
                             | v -> v),
                            System.Uri (
                                "endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ApiWithBasePath =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IApiWithBasePath =
        { new IApiWithBasePath with
            member _.GetPathParam (parameter : string, cancellationToken : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            System.Uri (
                                (match client.BaseAddress with
                                 | null ->
                                     raise (
                                         System.ArgumentNullException (
                                             nameof (client.BaseAddress),
                                             "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
                                         )
                                     )
                                 | v -> v),
                                System.Uri ("foo/", System.UriKind.Relative)
                            ),
                            System.Uri (
                                "endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = cancellationToken))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ApiWithBasePathAndAddress =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IApiWithBasePathAndAddress =
        { new IApiWithBasePathAndAddress with
            member _.GetPathParam (parameter : string, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            System.Uri (
                                (match client.BaseAddress with
                                 | null -> System.Uri "https://whatnot.com/thing/"
                                 | v -> v),
                                System.Uri ("foo/", System.UriKind.Relative)
                            ),
                            System.Uri (
                                "endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ApiWithAbsoluteBasePath =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IApiWithAbsoluteBasePath =
        { new IApiWithAbsoluteBasePath with
            member _.GetPathParam (parameter : string, cancellationToken : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            System.Uri (
                                (match client.BaseAddress with
                                 | null ->
                                     raise (
                                         System.ArgumentNullException (
                                             nameof (client.BaseAddress),
                                             "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
                                         )
                                     )
                                 | v -> v),
                                System.Uri ("/foo/", System.UriKind.Relative)
                            ),
                            System.Uri (
                                "endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = cancellationToken))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ApiWithAbsoluteBasePathAndAddress =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IApiWithAbsoluteBasePathAndAddress =
        { new IApiWithAbsoluteBasePathAndAddress with
            member _.GetPathParam (parameter : string, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            System.Uri (
                                (match client.BaseAddress with
                                 | null -> System.Uri "https://whatnot.com/thing/"
                                 | v -> v),
                                System.Uri ("/foo/", System.UriKind.Relative)
                            ),
                            System.Uri (
                                "endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ApiWithBasePathAndAbsoluteEndpoint =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IApiWithBasePathAndAbsoluteEndpoint =
        { new IApiWithBasePathAndAbsoluteEndpoint with
            member _.GetPathParam (parameter : string, cancellationToken : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            System.Uri (
                                (match client.BaseAddress with
                                 | null ->
                                     raise (
                                         System.ArgumentNullException (
                                             nameof (client.BaseAddress),
                                             "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
                                         )
                                     )
                                 | v -> v),
                                System.Uri ("foo/", System.UriKind.Relative)
                            ),
                            System.Uri (
                                "/endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = cancellationToken))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ApiWithBasePathAndAddressAndAbsoluteEndpoint =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IApiWithBasePathAndAddressAndAbsoluteEndpoint =
        { new IApiWithBasePathAndAddressAndAbsoluteEndpoint with
            member _.GetPathParam (parameter : string, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            System.Uri (
                                (match client.BaseAddress with
                                 | null -> System.Uri "https://whatnot.com/thing/"
                                 | v -> v),
                                System.Uri ("foo/", System.UriKind.Relative)
                            ),
                            System.Uri (
                                "/endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ApiWithAbsoluteBasePathAndAbsoluteEndpoint =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IApiWithAbsoluteBasePathAndAbsoluteEndpoint =
        { new IApiWithAbsoluteBasePathAndAbsoluteEndpoint with
            member _.GetPathParam (parameter : string, cancellationToken : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            System.Uri (
                                (match client.BaseAddress with
                                 | null ->
                                     raise (
                                         System.ArgumentNullException (
                                             nameof (client.BaseAddress),
                                             "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
                                         )
                                     )
                                 | v -> v),
                                System.Uri ("/foo/", System.UriKind.Relative)
                            ),
                            System.Uri (
                                "/endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = cancellationToken))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ApiWithAbsoluteBasePathAndAddressAndAbsoluteEndpoint =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IApiWithAbsoluteBasePathAndAddressAndAbsoluteEndpoint =
        { new IApiWithAbsoluteBasePathAndAddressAndAbsoluteEndpoint with
            member _.GetPathParam (parameter : string, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            System.Uri (
                                (match client.BaseAddress with
                                 | null -> System.Uri "https://whatnot.com/thing/"
                                 | v -> v),
                                System.Uri ("/foo/", System.UriKind.Relative)
                            ),
                            System.Uri (
                                "/endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ApiWithHeaders =
    /// Create a REST client. The input functions will be re-evaluated on every HTTP request to obtain the required values for the corresponding header properties.
    let make
        (someHeader : unit -> string)
        (someOtherHeader : unit -> int)
        (client : System.Net.Http.HttpClient)
        : IApiWithHeaders
        =
        { new IApiWithHeaders with
            member _.SomeHeader : string = someHeader ()
            member _.SomeOtherHeader : int = someOtherHeader ()

            member this.GetPathParam (parameter : string, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null ->
                                 raise (
                                     System.ArgumentNullException (
                                         nameof (client.BaseAddress),
                                         "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
                                     )
                                 )
                             | v -> v),
                            System.Uri (
                                "endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    do httpMessage.Headers.Add ("X-Foo", this.SomeHeader.ToString ())
                    do httpMessage.Headers.Add ("Authorization", this.SomeOtherHeader.ToString ())
                    do httpMessage.Headers.Add ("Header-Name", "Header-Value")
                    do httpMessage.Headers.Add ("Something-Else", "val")
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ApiWithHeaders2 =
    /// Create a REST client. The input functions will be re-evaluated on every HTTP request to obtain the required values for the corresponding header properties.
    let make
        (someHeader : unit -> string)
        (someOtherHeader : unit -> int)
        (client : System.Net.Http.HttpClient)
        : IApiWithHeaders2
        =
        { new IApiWithHeaders2 with
            member _.SomeHeader : string = someHeader ()
            member _.SomeOtherHeader : int = someOtherHeader ()

            member this.GetPathParam (parameter : string, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null ->
                                 raise (
                                     System.ArgumentNullException (
                                         nameof (client.BaseAddress),
                                         "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
                                     )
                                 )
                             | v -> v),
                            System.Uri (
                                "endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Get,
                            RequestUri = uri
                        )

                    do httpMessage.Headers.Add ("X-Foo", this.SomeHeader.ToString ())
                    do httpMessage.Headers.Add ("Authorization", this.SomeOtherHeader.ToString ())
                    do httpMessage.Headers.Add ("Header-Name", "Header-Value")
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ClientWithJsonBody =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IClientWithJsonBody =
        { new IClientWithJsonBody with
            member _.GetPathParam (parameter : string, mem : PureGym.Member, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null ->
                                 raise (
                                     System.ArgumentNullException (
                                         nameof (client.BaseAddress),
                                         "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
                                     )
                                 )
                             | v -> v),
                            System.Uri (
                                "endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams =
                        new System.Net.Http.StringContent (
                            mem |> PureGym.Member.toJsonNode |> (fun node -> node.ToJsonString ()),
                            null,
                            "application/json"
                        )

                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ClientWithJsonBodyOverridden =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IClientWithJsonBodyOverridden =
        { new IClientWithJsonBodyOverridden with
            member _.GetPathParam (parameter : string, mem : PureGym.Member, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null ->
                                 raise (
                                     System.ArgumentNullException (
                                         nameof (client.BaseAddress),
                                         "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
                                     )
                                 )
                             | v -> v),
                            System.Uri (
                                "endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams =
                        new System.Net.Http.StringContent (
                            mem |> PureGym.Member.toJsonNode |> (fun node -> node.ToJsonString ()),
                            null,
                            "application/ecmascript"
                        )

                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
        }
namespace PureGym

open System
open System.Threading
open System.Threading.Tasks
open System.IO
open System.Net
open System.Net.Http
open RestEase

/// Module for constructing a REST client.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix) ; RequireQualifiedAccess>]
module ClientWithStringBody =
    /// Create a REST client.
    let make (client : System.Net.Http.HttpClient) : IClientWithStringBody =
        { new IClientWithStringBody with
            member _.GetPathParam (parameter : string, mem : string, ct : CancellationToken option) =
                async {
                    let! ct = Async.CancellationToken

                    let uri =
                        System.Uri (
                            (match client.BaseAddress with
                             | null ->
                                 raise (
                                     System.ArgumentNullException (
                                         nameof (client.BaseAddress),
                                         "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
                                     )
                                 )
                             | v -> v),
                            System.Uri (
                                "endpoint/{param}"
                                    .Replace ("{param}", parameter.ToString () |> System.Uri.EscapeDataString),
                                System.UriKind.Relative
                            )
                        )

                    let httpMessage =
                        new System.Net.Http.HttpRequestMessage (
                            Method = System.Net.Http.HttpMethod.Post,
                            RequestUri = uri
                        )

                    let queryParams = new System.Net.Http.StringContent (mem)
                    do httpMessage.Content <- queryParams
                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
                    let response = response.EnsureSuccessStatusCode ()
                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
                    return responseString
                }
                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
        }