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


namespace PureGym

open System
open System.Text.Json.Serialization

/// Module containing JSON serializing extension members for the Member type
[<AutoOpen>]
module MemberJsonSerializeExtension =
    /// Extension methods for JSON parsing
    type Member with

        /// Serialize to a JSON node
        static member toJsonNode (input : Member) : System.Text.Json.Nodes.JsonNode =
            let node = System.Text.Json.Nodes.JsonObject ()

            do
                node.Add ("id", System.Text.Json.Nodes.JsonValue.Create<int> input.Id)
                node.Add ("compoundMemberId", System.Text.Json.Nodes.JsonValue.Create<string> input.CompoundMemberId)
                node.Add ("firstName", System.Text.Json.Nodes.JsonValue.Create<string> input.FirstName)
                node.Add ("lastName", System.Text.Json.Nodes.JsonValue.Create<string> input.LastName)
                node.Add ("homeGymId", System.Text.Json.Nodes.JsonValue.Create<int> input.HomeGymId)
                node.Add ("homeGymName", System.Text.Json.Nodes.JsonValue.Create<string> input.HomeGymName)
                node.Add ("emailAddress", System.Text.Json.Nodes.JsonValue.Create<string> input.EmailAddress)
                node.Add ("gymAccessPin", System.Text.Json.Nodes.JsonValue.Create<string> input.GymAccessPin)
                node.Add ("dateofBirth", System.Text.Json.Nodes.JsonValue.Create<DateOnly> input.DateOfBirth)
                node.Add ("mobileNumber", System.Text.Json.Nodes.JsonValue.Create<string> input.MobileNumber)
                node.Add ("postCode", System.Text.Json.Nodes.JsonValue.Create<string> input.Postcode)
                node.Add ("membershipName", System.Text.Json.Nodes.JsonValue.Create<string> input.MembershipName)
                node.Add ("membershipLevel", System.Text.Json.Nodes.JsonValue.Create<int> input.MembershipLevel)
                node.Add ("suspendedReason", System.Text.Json.Nodes.JsonValue.Create<int> input.SuspendedReason)
                node.Add ("memberStatus", System.Text.Json.Nodes.JsonValue.Create<int> input.MemberStatus)

            node :> _

namespace PureGym

/// Module containing JSON parsing methods for the GymOpeningHours type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module GymOpeningHours =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : GymOpeningHours =
        let OpeningHours =
            (match node.["openingHours"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("openingHours")
                     )
                 )
             | v -> v)
                .AsArray ()
            |> Seq.map (fun elt -> elt.AsValue().GetValue<string> ())
            |> List.ofSeq

        let IsAlwaysOpen =
            (match node.["isAlwaysOpen"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("isAlwaysOpen")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<bool> ()

        {
            IsAlwaysOpen = IsAlwaysOpen
            OpeningHours = OpeningHours
        }
namespace PureGym

/// Module containing JSON parsing methods for the GymAccessOptions type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module GymAccessOptions =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : GymAccessOptions =
        let QrCodeAccess =
            (match node.["qrCodeAccess"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("qrCodeAccess")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<bool> ()

        let PinAccess =
            (match node.["pinAccess"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("pinAccess")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<bool> ()

        {
            PinAccess = PinAccess
            QrCodeAccess = QrCodeAccess
        }
namespace PureGym

/// Module containing JSON parsing methods for the GymLocation type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module GymLocation =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : GymLocation =
        let Latitude =
            try
                (match node.["latitude"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("latitude")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<float> ()
            with :? System.InvalidOperationException as exc ->
                if exc.Message.Contains "cannot be converted to" then
                    if
                        System.Text.Json.Serialization.JsonNumberHandling.AllowReadingFromString = System.Text.Json.Serialization.JsonNumberHandling.AllowReadingFromString
                    then
                        (match node.["latitude"] with
                         | null ->
                             raise (
                                 System.Collections.Generic.KeyNotFoundException (
                                     sprintf "Required key '%s' not found on JSON object" ("latitude")
                                 )
                             )
                         | v -> v)
                            .AsValue()
                            .GetValue<string> ()
                        |> System.Double.Parse
                    else
                        reraise ()
                else
                    reraise ()

        let Longitude =
            try
                (match node.["longitude"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("longitude")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<float> ()
            with :? System.InvalidOperationException as exc ->
                if exc.Message.Contains "cannot be converted to" then
                    if
                        System.Text.Json.Serialization.JsonNumberHandling.AllowReadingFromString = System.Text.Json.Serialization.JsonNumberHandling.AllowReadingFromString
                    then
                        (match node.["longitude"] with
                         | null ->
                             raise (
                                 System.Collections.Generic.KeyNotFoundException (
                                     sprintf "Required key '%s' not found on JSON object" ("longitude")
                                 )
                             )
                         | v -> v)
                            .AsValue()
                            .GetValue<string> ()
                        |> System.Double.Parse
                    else
                        reraise ()
                else
                    reraise ()

        {
            Longitude = Longitude
            Latitude = Latitude
        }
namespace PureGym

/// Module containing JSON parsing methods for the GymAddress type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module GymAddress =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : GymAddress =
        let Postcode =
            (match node.["postcode"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("postcode")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()

        let County =
            match node.["county"] with
            | null -> None
            | v -> v.AsValue().GetValue<string> () |> Some

        let Town =
            (match node.["town"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("town")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()

        let AddressLine3 =
            match node.["addressLine3"] with
            | null -> None
            | v -> v.AsValue().GetValue<string> () |> Some

        let AddressLine2 =
            match node.["addressLine2"] with
            | null -> None
            | v -> v.AsValue().GetValue<string> () |> Some

        let AddressLine1 =
            (match node.["addressLine1"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("addressLine1")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()

        {
            AddressLine1 = AddressLine1
            AddressLine2 = AddressLine2
            AddressLine3 = AddressLine3
            Town = Town
            County = County
            Postcode = Postcode
        }
namespace PureGym

/// Module containing JSON parsing methods for the Gym type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module Gym =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : Gym =
        let ReopenDate =
            (match node.["reopenDate"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("reopenDate")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()

        let TimeZone =
            (match node.["timeZone"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("timeZone")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()

        let Location =
            GymLocation.jsonParse (
                match node.["location"] with
                | null ->
                    raise (
                        System.Collections.Generic.KeyNotFoundException (
                            sprintf "Required key '%s' not found on JSON object" ("location")
                        )
                    )
                | v -> v
            )

        let AccessOptions =
            GymAccessOptions.jsonParse (
                match node.["accessOptions"] with
                | null ->
                    raise (
                        System.Collections.Generic.KeyNotFoundException (
                            sprintf "Required key '%s' not found on JSON object" ("accessOptions")
                        )
                    )
                | v -> v
            )

        let GymOpeningHours =
            GymOpeningHours.jsonParse (
                match node.["gymOpeningHours"] with
                | null ->
                    raise (
                        System.Collections.Generic.KeyNotFoundException (
                            sprintf "Required key '%s' not found on JSON object" ("gymOpeningHours")
                        )
                    )
                | v -> v
            )

        let EmailAddress =
            (match node.["emailAddress"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("emailAddress")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()

        let PhoneNumber =
            (match node.["phoneNumber"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("phoneNumber")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()

        let Address =
            GymAddress.jsonParse (
                match node.["address"] with
                | null ->
                    raise (
                        System.Collections.Generic.KeyNotFoundException (
                            sprintf "Required key '%s' not found on JSON object" ("address")
                        )
                    )
                | v -> v
            )

        let Status =
            (match node.["status"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("status")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        let Id =
            (match node.["id"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("id")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        let Name =
            (match node.["name"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("name")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()

        {
            Name = Name
            Id = Id
            Status = Status
            Address = Address
            PhoneNumber = PhoneNumber
            EmailAddress = EmailAddress
            GymOpeningHours = GymOpeningHours
            AccessOptions = AccessOptions
            Location = Location
            TimeZone = TimeZone
            ReopenDate = ReopenDate
        }
namespace PureGym

/// Module containing JSON parsing extension members for the Member type
[<AutoOpen>]
module MemberJsonParseExtension =
    /// Extension methods for JSON parsing
    type Member with

        /// Parse from a JSON node.
        static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : Member =
            let MemberStatus =
                (match node.["memberStatus"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("memberStatus")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<int> ()

            let SuspendedReason =
                (match node.["suspendedReason"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("suspendedReason")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<int> ()

            let MembershipLevel =
                (match node.["membershipLevel"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("membershipLevel")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<int> ()

            let MembershipName =
                (match node.["membershipName"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("membershipName")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<string> ()

            let Postcode =
                (match node.["postCode"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("postCode")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<string> ()

            let MobileNumber =
                (match node.["mobileNumber"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("mobileNumber")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<string> ()

            let DateOfBirth =
                (match node.["dateofBirth"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("dateofBirth")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<string> ()
                |> System.DateOnly.Parse

            let GymAccessPin =
                (match node.["gymAccessPin"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("gymAccessPin")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<string> ()

            let EmailAddress =
                (match node.["emailAddress"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("emailAddress")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<string> ()

            let HomeGymName =
                (match node.["homeGymName"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("homeGymName")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<string> ()

            let HomeGymId =
                (match node.["homeGymId"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("homeGymId")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<int> ()

            let LastName =
                (match node.["lastName"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("lastName")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<string> ()

            let FirstName =
                (match node.["firstName"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("firstName")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<string> ()

            let CompoundMemberId =
                (match node.["compoundMemberId"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("compoundMemberId")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<string> ()

            let Id =
                (match node.["id"] with
                 | null ->
                     raise (
                         System.Collections.Generic.KeyNotFoundException (
                             sprintf "Required key '%s' not found on JSON object" ("id")
                         )
                     )
                 | v -> v)
                    .AsValue()
                    .GetValue<int> ()

            {
                Id = Id
                CompoundMemberId = CompoundMemberId
                FirstName = FirstName
                LastName = LastName
                HomeGymId = HomeGymId
                HomeGymName = HomeGymName
                EmailAddress = EmailAddress
                GymAccessPin = GymAccessPin
                DateOfBirth = DateOfBirth
                MobileNumber = MobileNumber
                Postcode = Postcode
                MembershipName = MembershipName
                MembershipLevel = MembershipLevel
                SuspendedReason = SuspendedReason
                MemberStatus = MemberStatus
            }
namespace PureGym

/// Module containing JSON parsing methods for the GymAttendance type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module GymAttendance =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : GymAttendance =
        let MaximumCapacity =
            (match node.["maximumCapacity"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("maximumCapacity")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        let LastRefreshedPeopleInClasses =
            (match node.["lastRefreshedPeopleInClasses"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("lastRefreshedPeopleInClasses")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()
            |> System.DateTime.Parse

        let LastRefreshed =
            (match node.["lastRefreshed"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("lastRefreshed")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()
            |> System.DateTime.Parse

        let AttendanceTime =
            (match node.["attendanceTime"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("attendanceTime")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()
            |> System.DateTime.Parse

        let IsApproximate =
            (match node.["isApproximate"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("isApproximate")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<bool> ()

        let TotalPeopleSuffix =
            match node.["totalPeopleSuffix"] with
            | null -> None
            | v -> v.AsValue().GetValue<string> () |> Some

        let TotalPeopleInClasses =
            (match node.["totalPeopleInClasses"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("totalPeopleInClasses")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        let TotalPeopleInGym =
            (match node.["totalPeopleInGym"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("totalPeopleInGym")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        let Description =
            (match node.["description"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("description")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()

        {
            Description = Description
            TotalPeopleInGym = TotalPeopleInGym
            TotalPeopleInClasses = TotalPeopleInClasses
            TotalPeopleSuffix = TotalPeopleSuffix
            IsApproximate = IsApproximate
            AttendanceTime = AttendanceTime
            LastRefreshed = LastRefreshed
            LastRefreshedPeopleInClasses = LastRefreshedPeopleInClasses
            MaximumCapacity = MaximumCapacity
        }
namespace PureGym

/// Module containing JSON parsing methods for the MemberActivityDto type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module MemberActivityDto =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : MemberActivityDto =
        let LastRefreshed =
            (match node.["lastRefreshed"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("lastRefreshed")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()
            |> System.DateTime.Parse

        let IsEstimated =
            (match node.["isEstimated"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("isEstimated")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<bool> ()

        let TotalClasses =
            (match node.["totalClasses"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("totalClasses")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        let TotalVisits =
            (match node.["totalVisits"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("totalVisits")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        let AverageDuration =
            (match node.["averageDuration"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("averageDuration")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        let TotalDuration =
            (match node.["totalDuration"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("totalDuration")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        {
            TotalDuration = TotalDuration
            AverageDuration = AverageDuration
            TotalVisits = TotalVisits
            TotalClasses = TotalClasses
            IsEstimated = IsEstimated
            LastRefreshed = LastRefreshed
        }
namespace PureGym

/// Module containing JSON parsing methods for the SessionsAggregate type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module SessionsAggregate =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : SessionsAggregate =
        let Duration =
            (match node.["Duration"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("Duration")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        let Visits =
            (match node.["Visits"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("Visits")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        let Activities =
            (match node.["Activities"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("Activities")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        {
            Activities = Activities
            Visits = Visits
            Duration = Duration
        }
namespace PureGym

/// Module containing JSON parsing methods for the VisitGym type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module VisitGym =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : VisitGym =
        let Status =
            (match node.["Status"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("Status")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()

        let Name =
            (match node.["Name"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("Name")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()

        let Id =
            (match node.["Id"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("Id")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        {
            Id = Id
            Name = Name
            Status = Status
        }
namespace PureGym

/// Module containing JSON parsing methods for the Visit type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module Visit =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : Visit =
        let Gym =
            VisitGym.jsonParse (
                match node.["Gym"] with
                | null ->
                    raise (
                        System.Collections.Generic.KeyNotFoundException (
                            sprintf "Required key '%s' not found on JSON object" ("Gym")
                        )
                    )
                | v -> v
            )

        let Duration =
            (match node.["Duration"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("Duration")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<int> ()

        let StartTime =
            (match node.["StartTime"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("StartTime")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()
            |> System.DateTime.Parse

        let IsDurationEstimated =
            (match node.["IsDurationEstimated"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("IsDurationEstimated")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<bool> ()

        {
            IsDurationEstimated = IsDurationEstimated
            StartTime = StartTime
            Duration = Duration
            Gym = Gym
        }
namespace PureGym

/// Module containing JSON parsing methods for the SessionsSummary type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module SessionsSummary =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : SessionsSummary =
        let ThisWeek =
            SessionsAggregate.jsonParse (
                match node.["ThisWeek"] with
                | null ->
                    raise (
                        System.Collections.Generic.KeyNotFoundException (
                            sprintf "Required key '%s' not found on JSON object" ("ThisWeek")
                        )
                    )
                | v -> v
            )

        let Total =
            SessionsAggregate.jsonParse (
                match node.["Total"] with
                | null ->
                    raise (
                        System.Collections.Generic.KeyNotFoundException (
                            sprintf "Required key '%s' not found on JSON object" ("Total")
                        )
                    )
                | v -> v
            )

        {
            Total = Total
            ThisWeek = ThisWeek
        }
namespace PureGym

/// Module containing JSON parsing methods for the Sessions type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module Sessions =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : Sessions =
        let Visits =
            (match node.["Visits"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("Visits")
                     )
                 )
             | v -> v)
                .AsArray ()
            |> Seq.map (fun elt -> Visit.jsonParse elt)
            |> List.ofSeq

        let Summary =
            SessionsSummary.jsonParse (
                match node.["Summary"] with
                | null ->
                    raise (
                        System.Collections.Generic.KeyNotFoundException (
                            sprintf "Required key '%s' not found on JSON object" ("Summary")
                        )
                    )
                | v -> v
            )

        {
            Summary = Summary
            Visits = Visits
        }
namespace PureGym

/// Module containing JSON parsing methods for the UriThing type
[<RequireQualifiedAccess>]
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module UriThing =
    /// Parse from a JSON node.
    let jsonParse (node : System.Text.Json.Nodes.JsonNode) : UriThing =
        let SomeUri =
            (match node.["someUri"] with
             | null ->
                 raise (
                     System.Collections.Generic.KeyNotFoundException (
                         sprintf "Required key '%s' not found on JSON object" ("someUri")
                     )
                 )
             | v -> v)
                .AsValue()
                .GetValue<string> ()
            |> System.Uri

        {
            SomeUri = SomeUri
        }