text: //////////////////////////////////////////////////////
  // Copyright (C) Microsoft. 2018. All rights reserved.
  //////////////////////////////////////////////////////
  
  
  // This is automatically generated by PlayFab SDKGenerator. DO NOT modify this manually!
  
  #include "Core/PlayFabClientDataModels.h"
  #include "Core/PlayFabJsonHelpers.h"
  
  using namespace PlayFab;
  using namespace PlayFab::ClientModels;
  
  PlayFab::ClientModels::FAcceptTradeRequest::~FAcceptTradeRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FAcceptTradeRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AcceptedInventoryInstanceIds.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("AcceptedInventoryInstanceIds"));
          for (const FString& item : AcceptedInventoryInstanceIds)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteIdentifierPrefix(TEXT("OfferingPlayerId")); writer->WriteValue(OfferingPlayerId);
  
      writer->WriteIdentifierPrefix(TEXT("TradeId")); writer->WriteValue(TradeId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAcceptTradeRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      obj->TryGetStringArrayField(TEXT("AcceptedInventoryInstanceIds"), AcceptedInventoryInstanceIds);
  
      const TSharedPtr<FJsonValue> OfferingPlayerIdValue = obj->TryGetField(TEXT("OfferingPlayerId"));
      if (OfferingPlayerIdValue.IsValid() && !OfferingPlayerIdValue->IsNull())
      {
          FString TmpValue;
          if (OfferingPlayerIdValue->TryGetString(TmpValue)) { OfferingPlayerId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TradeIdValue = obj->TryGetField(TEXT("TradeId"));
      if (TradeIdValue.IsValid() && !TradeIdValue->IsNull())
      {
          FString TmpValue;
          if (TradeIdValue->TryGetString(TmpValue)) { TradeId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeTradeStatusEnumJSON(TradeStatus enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case TradeStatusInvalid: writer->WriteValue(TEXT("Invalid")); break;
      case TradeStatusOpening: writer->WriteValue(TEXT("Opening")); break;
      case TradeStatusOpen: writer->WriteValue(TEXT("Open")); break;
      case TradeStatusAccepting: writer->WriteValue(TEXT("Accepting")); break;
      case TradeStatusAccepted: writer->WriteValue(TEXT("Accepted")); break;
      case TradeStatusFilled: writer->WriteValue(TEXT("Filled")); break;
      case TradeStatusCancelled: writer->WriteValue(TEXT("Cancelled")); break;
      }
  }
  
  ClientModels::TradeStatus PlayFab::ClientModels::readTradeStatusFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readTradeStatusFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::TradeStatus PlayFab::ClientModels::readTradeStatusFromValue(const FString& value)
  {
      static TMap<FString, TradeStatus> _TradeStatusMap;
      if (_TradeStatusMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _TradeStatusMap.Add(TEXT("Invalid"), TradeStatusInvalid);
          _TradeStatusMap.Add(TEXT("Opening"), TradeStatusOpening);
          _TradeStatusMap.Add(TEXT("Open"), TradeStatusOpen);
          _TradeStatusMap.Add(TEXT("Accepting"), TradeStatusAccepting);
          _TradeStatusMap.Add(TEXT("Accepted"), TradeStatusAccepted);
          _TradeStatusMap.Add(TEXT("Filled"), TradeStatusFilled);
          _TradeStatusMap.Add(TEXT("Cancelled"), TradeStatusCancelled);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _TradeStatusMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return TradeStatusInvalid; // Basically critical fail
  }
  
  PlayFab::ClientModels::FTradeInfo::~FTradeInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FTradeInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AcceptedInventoryInstanceIds.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("AcceptedInventoryInstanceIds"));
          for (const FString& item : AcceptedInventoryInstanceIds)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (AcceptedPlayerId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AcceptedPlayerId")); writer->WriteValue(AcceptedPlayerId); }
  
      if (AllowedPlayerIds.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("AllowedPlayerIds"));
          for (const FString& item : AllowedPlayerIds)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (CancelledAt.notNull()) { writer->WriteIdentifierPrefix(TEXT("CancelledAt")); writeDatetime(CancelledAt, writer); }
  
      if (FilledAt.notNull()) { writer->WriteIdentifierPrefix(TEXT("FilledAt")); writeDatetime(FilledAt, writer); }
  
      if (InvalidatedAt.notNull()) { writer->WriteIdentifierPrefix(TEXT("InvalidatedAt")); writeDatetime(InvalidatedAt, writer); }
  
      if (OfferedCatalogItemIds.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("OfferedCatalogItemIds"));
          for (const FString& item : OfferedCatalogItemIds)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (OfferedInventoryInstanceIds.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("OfferedInventoryInstanceIds"));
          for (const FString& item : OfferedInventoryInstanceIds)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (OfferingPlayerId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("OfferingPlayerId")); writer->WriteValue(OfferingPlayerId); }
  
      if (OpenedAt.notNull()) { writer->WriteIdentifierPrefix(TEXT("OpenedAt")); writeDatetime(OpenedAt, writer); }
  
      if (RequestedCatalogItemIds.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("RequestedCatalogItemIds"));
          for (const FString& item : RequestedCatalogItemIds)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (Status.notNull()) { writer->WriteIdentifierPrefix(TEXT("Status")); writeTradeStatusEnumJSON(Status, writer); }
  
      if (TradeId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TradeId")); writer->WriteValue(TradeId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FTradeInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      obj->TryGetStringArrayField(TEXT("AcceptedInventoryInstanceIds"), AcceptedInventoryInstanceIds);
  
      const TSharedPtr<FJsonValue> AcceptedPlayerIdValue = obj->TryGetField(TEXT("AcceptedPlayerId"));
      if (AcceptedPlayerIdValue.IsValid() && !AcceptedPlayerIdValue->IsNull())
      {
          FString TmpValue;
          if (AcceptedPlayerIdValue->TryGetString(TmpValue)) { AcceptedPlayerId = TmpValue; }
      }
  
      obj->TryGetStringArrayField(TEXT("AllowedPlayerIds"), AllowedPlayerIds);
  
      const TSharedPtr<FJsonValue> CancelledAtValue = obj->TryGetField(TEXT("CancelledAt"));
      if (CancelledAtValue.IsValid())
          CancelledAt = readDatetime(CancelledAtValue);
  
  
      const TSharedPtr<FJsonValue> FilledAtValue = obj->TryGetField(TEXT("FilledAt"));
      if (FilledAtValue.IsValid())
          FilledAt = readDatetime(FilledAtValue);
  
  
      const TSharedPtr<FJsonValue> InvalidatedAtValue = obj->TryGetField(TEXT("InvalidatedAt"));
      if (InvalidatedAtValue.IsValid())
          InvalidatedAt = readDatetime(InvalidatedAtValue);
  
  
      obj->TryGetStringArrayField(TEXT("OfferedCatalogItemIds"), OfferedCatalogItemIds);
  
      obj->TryGetStringArrayField(TEXT("OfferedInventoryInstanceIds"), OfferedInventoryInstanceIds);
  
      const TSharedPtr<FJsonValue> OfferingPlayerIdValue = obj->TryGetField(TEXT("OfferingPlayerId"));
      if (OfferingPlayerIdValue.IsValid() && !OfferingPlayerIdValue->IsNull())
      {
          FString TmpValue;
          if (OfferingPlayerIdValue->TryGetString(TmpValue)) { OfferingPlayerId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> OpenedAtValue = obj->TryGetField(TEXT("OpenedAt"));
      if (OpenedAtValue.IsValid())
          OpenedAt = readDatetime(OpenedAtValue);
  
  
      obj->TryGetStringArrayField(TEXT("RequestedCatalogItemIds"), RequestedCatalogItemIds);
  
      Status = readTradeStatusFromValue(obj->TryGetField(TEXT("Status")));
  
      const TSharedPtr<FJsonValue> TradeIdValue = obj->TryGetField(TEXT("TradeId"));
      if (TradeIdValue.IsValid() && !TradeIdValue->IsNull())
      {
          FString TmpValue;
          if (TradeIdValue->TryGetString(TmpValue)) { TradeId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAcceptTradeResponse::~FAcceptTradeResponse()
  {
      //if (Trade != nullptr) delete Trade;
  
  }
  
  void PlayFab::ClientModels::FAcceptTradeResponse::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Trade.IsValid()) { writer->WriteIdentifierPrefix(TEXT("Trade")); Trade->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAcceptTradeResponse::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> TradeValue = obj->TryGetField(TEXT("Trade"));
      if (TradeValue.IsValid() && !TradeValue->IsNull())
      {
          Trade = MakeShareable(new FTradeInfo(TradeValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAdCampaignAttributionModel::~FAdCampaignAttributionModel()
  {
  
  }
  
  void PlayFab::ClientModels::FAdCampaignAttributionModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("AttributedAt")); writeDatetime(AttributedAt, writer);
  
      if (CampaignId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CampaignId")); writer->WriteValue(CampaignId); }
  
      if (Platform.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Platform")); writer->WriteValue(Platform); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAdCampaignAttributionModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AttributedAtValue = obj->TryGetField(TEXT("AttributedAt"));
      if (AttributedAtValue.IsValid())
          AttributedAt = readDatetime(AttributedAtValue);
  
  
      const TSharedPtr<FJsonValue> CampaignIdValue = obj->TryGetField(TEXT("CampaignId"));
      if (CampaignIdValue.IsValid() && !CampaignIdValue->IsNull())
      {
          FString TmpValue;
          if (CampaignIdValue->TryGetString(TmpValue)) { CampaignId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlatformValue = obj->TryGetField(TEXT("Platform"));
      if (PlatformValue.IsValid() && !PlatformValue->IsNull())
      {
          FString TmpValue;
          if (PlatformValue->TryGetString(TmpValue)) { Platform = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAddFriendRequest::~FAddFriendRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FAddFriendRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (FriendEmail.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FriendEmail")); writer->WriteValue(FriendEmail); }
  
      if (FriendPlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FriendPlayFabId")); writer->WriteValue(FriendPlayFabId); }
  
      if (FriendTitleDisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FriendTitleDisplayName")); writer->WriteValue(FriendTitleDisplayName); }
  
      if (FriendUsername.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FriendUsername")); writer->WriteValue(FriendUsername); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAddFriendRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> FriendEmailValue = obj->TryGetField(TEXT("FriendEmail"));
      if (FriendEmailValue.IsValid() && !FriendEmailValue->IsNull())
      {
          FString TmpValue;
          if (FriendEmailValue->TryGetString(TmpValue)) { FriendEmail = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> FriendPlayFabIdValue = obj->TryGetField(TEXT("FriendPlayFabId"));
      if (FriendPlayFabIdValue.IsValid() && !FriendPlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (FriendPlayFabIdValue->TryGetString(TmpValue)) { FriendPlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> FriendTitleDisplayNameValue = obj->TryGetField(TEXT("FriendTitleDisplayName"));
      if (FriendTitleDisplayNameValue.IsValid() && !FriendTitleDisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (FriendTitleDisplayNameValue->TryGetString(TmpValue)) { FriendTitleDisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> FriendUsernameValue = obj->TryGetField(TEXT("FriendUsername"));
      if (FriendUsernameValue.IsValid() && !FriendUsernameValue->IsNull())
      {
          FString TmpValue;
          if (FriendUsernameValue->TryGetString(TmpValue)) { FriendUsername = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAddFriendResult::~FAddFriendResult()
  {
  
  }
  
  void PlayFab::ClientModels::FAddFriendResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Created")); writer->WriteValue(Created);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAddFriendResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CreatedValue = obj->TryGetField(TEXT("Created"));
      if (CreatedValue.IsValid() && !CreatedValue->IsNull())
      {
          bool TmpValue;
          if (CreatedValue->TryGetBool(TmpValue)) { Created = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGenericServiceId::~FGenericServiceId()
  {
  
  }
  
  void PlayFab::ClientModels::FGenericServiceId::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("ServiceName")); writer->WriteValue(ServiceName);
  
      writer->WriteIdentifierPrefix(TEXT("UserId")); writer->WriteValue(UserId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGenericServiceId::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ServiceNameValue = obj->TryGetField(TEXT("ServiceName"));
      if (ServiceNameValue.IsValid() && !ServiceNameValue->IsNull())
      {
          FString TmpValue;
          if (ServiceNameValue->TryGetString(TmpValue)) { ServiceName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UserIdValue = obj->TryGetField(TEXT("UserId"));
      if (UserIdValue.IsValid() && !UserIdValue->IsNull())
      {
          FString TmpValue;
          if (UserIdValue->TryGetString(TmpValue)) { UserId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAddGenericIDRequest::~FAddGenericIDRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FAddGenericIDRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("GenericId")); GenericId.writeJSON(writer);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAddGenericIDRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> GenericIdValue = obj->TryGetField(TEXT("GenericId"));
      if (GenericIdValue.IsValid() && !GenericIdValue->IsNull())
      {
          GenericId = FGenericServiceId(GenericIdValue->AsObject());
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAddGenericIDResult::~FAddGenericIDResult()
  {
  
  }
  
  void PlayFab::ClientModels::FAddGenericIDResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAddGenericIDResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAddOrUpdateContactEmailRequest::~FAddOrUpdateContactEmailRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FAddOrUpdateContactEmailRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("EmailAddress")); writer->WriteValue(EmailAddress);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAddOrUpdateContactEmailRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EmailAddressValue = obj->TryGetField(TEXT("EmailAddress"));
      if (EmailAddressValue.IsValid() && !EmailAddressValue->IsNull())
      {
          FString TmpValue;
          if (EmailAddressValue->TryGetString(TmpValue)) { EmailAddress = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAddOrUpdateContactEmailResult::~FAddOrUpdateContactEmailResult()
  {
  
  }
  
  void PlayFab::ClientModels::FAddOrUpdateContactEmailResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAddOrUpdateContactEmailResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAddSharedGroupMembersRequest::~FAddSharedGroupMembersRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FAddSharedGroupMembersRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("PlayFabIds"));
      for (const FString& item : PlayFabIds)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteIdentifierPrefix(TEXT("SharedGroupId")); writer->WriteValue(SharedGroupId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAddSharedGroupMembersRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("PlayFabIds"), PlayFabIds);
  
      const TSharedPtr<FJsonValue> SharedGroupIdValue = obj->TryGetField(TEXT("SharedGroupId"));
      if (SharedGroupIdValue.IsValid() && !SharedGroupIdValue->IsNull())
      {
          FString TmpValue;
          if (SharedGroupIdValue->TryGetString(TmpValue)) { SharedGroupId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAddSharedGroupMembersResult::~FAddSharedGroupMembersResult()
  {
  
  }
  
  void PlayFab::ClientModels::FAddSharedGroupMembersResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAddSharedGroupMembersResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAddUsernamePasswordRequest::~FAddUsernamePasswordRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FAddUsernamePasswordRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Email")); writer->WriteValue(Email);
  
      writer->WriteIdentifierPrefix(TEXT("Password")); writer->WriteValue(Password);
  
      writer->WriteIdentifierPrefix(TEXT("Username")); writer->WriteValue(Username);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAddUsernamePasswordRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EmailValue = obj->TryGetField(TEXT("Email"));
      if (EmailValue.IsValid() && !EmailValue->IsNull())
      {
          FString TmpValue;
          if (EmailValue->TryGetString(TmpValue)) { Email = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PasswordValue = obj->TryGetField(TEXT("Password"));
      if (PasswordValue.IsValid() && !PasswordValue->IsNull())
      {
          FString TmpValue;
          if (PasswordValue->TryGetString(TmpValue)) { Password = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UsernameValue = obj->TryGetField(TEXT("Username"));
      if (UsernameValue.IsValid() && !UsernameValue->IsNull())
      {
          FString TmpValue;
          if (UsernameValue->TryGetString(TmpValue)) { Username = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAddUsernamePasswordResult::~FAddUsernamePasswordResult()
  {
  
  }
  
  void PlayFab::ClientModels::FAddUsernamePasswordResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Username.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Username")); writer->WriteValue(Username); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAddUsernamePasswordResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> UsernameValue = obj->TryGetField(TEXT("Username"));
      if (UsernameValue.IsValid() && !UsernameValue->IsNull())
      {
          FString TmpValue;
          if (UsernameValue->TryGetString(TmpValue)) { Username = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAddUserVirtualCurrencyRequest::~FAddUserVirtualCurrencyRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FAddUserVirtualCurrencyRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Amount")); writer->WriteValue(Amount);
  
      writer->WriteIdentifierPrefix(TEXT("VirtualCurrency")); writer->WriteValue(VirtualCurrency);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAddUserVirtualCurrencyRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AmountValue = obj->TryGetField(TEXT("Amount"));
      if (AmountValue.IsValid() && !AmountValue->IsNull())
      {
          int32 TmpValue;
          if (AmountValue->TryGetNumber(TmpValue)) { Amount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VirtualCurrencyValue = obj->TryGetField(TEXT("VirtualCurrency"));
      if (VirtualCurrencyValue.IsValid() && !VirtualCurrencyValue->IsNull())
      {
          FString TmpValue;
          if (VirtualCurrencyValue->TryGetString(TmpValue)) { VirtualCurrency = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAndroidDevicePushNotificationRegistrationRequest::~FAndroidDevicePushNotificationRegistrationRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FAndroidDevicePushNotificationRegistrationRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ConfirmationMessage.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ConfirmationMessage")); writer->WriteValue(ConfirmationMessage); }
  
      writer->WriteIdentifierPrefix(TEXT("DeviceToken")); writer->WriteValue(DeviceToken);
  
      if (SendPushNotificationConfirmation.notNull()) { writer->WriteIdentifierPrefix(TEXT("SendPushNotificationConfirmation")); writer->WriteValue(SendPushNotificationConfirmation); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAndroidDevicePushNotificationRegistrationRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ConfirmationMessageValue = obj->TryGetField(TEXT("ConfirmationMessage"));
      if (ConfirmationMessageValue.IsValid() && !ConfirmationMessageValue->IsNull())
      {
          FString TmpValue;
          if (ConfirmationMessageValue->TryGetString(TmpValue)) { ConfirmationMessage = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> DeviceTokenValue = obj->TryGetField(TEXT("DeviceToken"));
      if (DeviceTokenValue.IsValid() && !DeviceTokenValue->IsNull())
      {
          FString TmpValue;
          if (DeviceTokenValue->TryGetString(TmpValue)) { DeviceToken = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SendPushNotificationConfirmationValue = obj->TryGetField(TEXT("SendPushNotificationConfirmation"));
      if (SendPushNotificationConfirmationValue.IsValid() && !SendPushNotificationConfirmationValue->IsNull())
      {
          bool TmpValue;
          if (SendPushNotificationConfirmationValue->TryGetBool(TmpValue)) { SendPushNotificationConfirmation = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAndroidDevicePushNotificationRegistrationResult::~FAndroidDevicePushNotificationRegistrationResult()
  {
  
  }
  
  void PlayFab::ClientModels::FAndroidDevicePushNotificationRegistrationResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAndroidDevicePushNotificationRegistrationResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAttributeInstallRequest::~FAttributeInstallRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FAttributeInstallRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Adid.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Adid")); writer->WriteValue(Adid); }
  
      if (Idfa.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Idfa")); writer->WriteValue(Idfa); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAttributeInstallRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AdidValue = obj->TryGetField(TEXT("Adid"));
      if (AdidValue.IsValid() && !AdidValue->IsNull())
      {
          FString TmpValue;
          if (AdidValue->TryGetString(TmpValue)) { Adid = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IdfaValue = obj->TryGetField(TEXT("Idfa"));
      if (IdfaValue.IsValid() && !IdfaValue->IsNull())
      {
          FString TmpValue;
          if (IdfaValue->TryGetString(TmpValue)) { Idfa = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FAttributeInstallResult::~FAttributeInstallResult()
  {
  
  }
  
  void PlayFab::ClientModels::FAttributeInstallResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FAttributeInstallResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCancelTradeRequest::~FCancelTradeRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FCancelTradeRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("TradeId")); writer->WriteValue(TradeId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCancelTradeRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> TradeIdValue = obj->TryGetField(TEXT("TradeId"));
      if (TradeIdValue.IsValid() && !TradeIdValue->IsNull())
      {
          FString TmpValue;
          if (TradeIdValue->TryGetString(TmpValue)) { TradeId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCancelTradeResponse::~FCancelTradeResponse()
  {
      //if (Trade != nullptr) delete Trade;
  
  }
  
  void PlayFab::ClientModels::FCancelTradeResponse::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Trade.IsValid()) { writer->WriteIdentifierPrefix(TEXT("Trade")); Trade->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCancelTradeResponse::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> TradeValue = obj->TryGetField(TEXT("Trade"));
      if (TradeValue.IsValid() && !TradeValue->IsNull())
      {
          Trade = MakeShareable(new FTradeInfo(TradeValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCartItem::~FCartItem()
  {
  
  }
  
  void PlayFab::ClientModels::FCartItem::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Description.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Description")); writer->WriteValue(Description); }
  
      if (DisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DisplayName")); writer->WriteValue(DisplayName); }
  
      if (ItemClass.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ItemClass")); writer->WriteValue(ItemClass); }
  
      if (ItemId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ItemId")); writer->WriteValue(ItemId); }
  
      if (ItemInstanceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ItemInstanceId")); writer->WriteValue(ItemInstanceId); }
  
      if (RealCurrencyPrices.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("RealCurrencyPrices"));
          for (TMap<FString, uint32>::TConstIterator It(RealCurrencyPrices); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue(static_cast<int64>((*It).Value));
          }
          writer->WriteObjectEnd();
      }
  
      if (VCAmount.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VCAmount"));
          for (TMap<FString, uint32>::TConstIterator It(VCAmount); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue(static_cast<int64>((*It).Value));
          }
          writer->WriteObjectEnd();
      }
  
      if (VirtualCurrencyPrices.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VirtualCurrencyPrices"));
          for (TMap<FString, uint32>::TConstIterator It(VirtualCurrencyPrices); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue(static_cast<int64>((*It).Value));
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCartItem::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DescriptionValue = obj->TryGetField(TEXT("Description"));
      if (DescriptionValue.IsValid() && !DescriptionValue->IsNull())
      {
          FString TmpValue;
          if (DescriptionValue->TryGetString(TmpValue)) { Description = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> DisplayNameValue = obj->TryGetField(TEXT("DisplayName"));
      if (DisplayNameValue.IsValid() && !DisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (DisplayNameValue->TryGetString(TmpValue)) { DisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemClassValue = obj->TryGetField(TEXT("ItemClass"));
      if (ItemClassValue.IsValid() && !ItemClassValue->IsNull())
      {
          FString TmpValue;
          if (ItemClassValue->TryGetString(TmpValue)) { ItemClass = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemIdValue = obj->TryGetField(TEXT("ItemId"));
      if (ItemIdValue.IsValid() && !ItemIdValue->IsNull())
      {
          FString TmpValue;
          if (ItemIdValue->TryGetString(TmpValue)) { ItemId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemInstanceIdValue = obj->TryGetField(TEXT("ItemInstanceId"));
      if (ItemInstanceIdValue.IsValid() && !ItemInstanceIdValue->IsNull())
      {
          FString TmpValue;
          if (ItemInstanceIdValue->TryGetString(TmpValue)) { ItemInstanceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonObject>* RealCurrencyPricesObject;
      if (obj->TryGetObjectField(TEXT("RealCurrencyPrices"), RealCurrencyPricesObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*RealCurrencyPricesObject)->Values); It; ++It)
          {
              uint32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              RealCurrencyPrices.Add(It.Key(), TmpValue);
          }
      }
  
      const TSharedPtr<FJsonObject>* VCAmountObject;
      if (obj->TryGetObjectField(TEXT("VCAmount"), VCAmountObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VCAmountObject)->Values); It; ++It)
          {
              uint32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              VCAmount.Add(It.Key(), TmpValue);
          }
      }
  
      const TSharedPtr<FJsonObject>* VirtualCurrencyPricesObject;
      if (obj->TryGetObjectField(TEXT("VirtualCurrencyPrices"), VirtualCurrencyPricesObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VirtualCurrencyPricesObject)->Values); It; ++It)
          {
              uint32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              VirtualCurrencyPrices.Add(It.Key(), TmpValue);
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCatalogItemBundleInfo::~FCatalogItemBundleInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FCatalogItemBundleInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (BundledItems.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("BundledItems"));
          for (const FString& item : BundledItems)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (BundledResultTables.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("BundledResultTables"));
          for (const FString& item : BundledResultTables)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (BundledVirtualCurrencies.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("BundledVirtualCurrencies"));
          for (TMap<FString, uint32>::TConstIterator It(BundledVirtualCurrencies); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue(static_cast<int64>((*It).Value));
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCatalogItemBundleInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      obj->TryGetStringArrayField(TEXT("BundledItems"), BundledItems);
  
      obj->TryGetStringArrayField(TEXT("BundledResultTables"), BundledResultTables);
  
      const TSharedPtr<FJsonObject>* BundledVirtualCurrenciesObject;
      if (obj->TryGetObjectField(TEXT("BundledVirtualCurrencies"), BundledVirtualCurrenciesObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*BundledVirtualCurrenciesObject)->Values); It; ++It)
          {
              uint32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              BundledVirtualCurrencies.Add(It.Key(), TmpValue);
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCatalogItemConsumableInfo::~FCatalogItemConsumableInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FCatalogItemConsumableInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (UsageCount.notNull()) { writer->WriteIdentifierPrefix(TEXT("UsageCount")); writer->WriteValue(static_cast<int64>(UsageCount)); }
  
      if (UsagePeriod.notNull()) { writer->WriteIdentifierPrefix(TEXT("UsagePeriod")); writer->WriteValue(static_cast<int64>(UsagePeriod)); }
  
      if (UsagePeriodGroup.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("UsagePeriodGroup")); writer->WriteValue(UsagePeriodGroup); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCatalogItemConsumableInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> UsageCountValue = obj->TryGetField(TEXT("UsageCount"));
      if (UsageCountValue.IsValid() && !UsageCountValue->IsNull())
      {
          uint32 TmpValue;
          if (UsageCountValue->TryGetNumber(TmpValue)) { UsageCount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UsagePeriodValue = obj->TryGetField(TEXT("UsagePeriod"));
      if (UsagePeriodValue.IsValid() && !UsagePeriodValue->IsNull())
      {
          uint32 TmpValue;
          if (UsagePeriodValue->TryGetNumber(TmpValue)) { UsagePeriod = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UsagePeriodGroupValue = obj->TryGetField(TEXT("UsagePeriodGroup"));
      if (UsagePeriodGroupValue.IsValid() && !UsagePeriodGroupValue->IsNull())
      {
          FString TmpValue;
          if (UsagePeriodGroupValue->TryGetString(TmpValue)) { UsagePeriodGroup = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCatalogItemContainerInfo::~FCatalogItemContainerInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FCatalogItemContainerInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ItemContents.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("ItemContents"));
          for (const FString& item : ItemContents)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (KeyItemId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("KeyItemId")); writer->WriteValue(KeyItemId); }
  
      if (ResultTableContents.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("ResultTableContents"));
          for (const FString& item : ResultTableContents)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (VirtualCurrencyContents.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VirtualCurrencyContents"));
          for (TMap<FString, uint32>::TConstIterator It(VirtualCurrencyContents); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue(static_cast<int64>((*It).Value));
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCatalogItemContainerInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      obj->TryGetStringArrayField(TEXT("ItemContents"), ItemContents);
  
      const TSharedPtr<FJsonValue> KeyItemIdValue = obj->TryGetField(TEXT("KeyItemId"));
      if (KeyItemIdValue.IsValid() && !KeyItemIdValue->IsNull())
      {
          FString TmpValue;
          if (KeyItemIdValue->TryGetString(TmpValue)) { KeyItemId = TmpValue; }
      }
  
      obj->TryGetStringArrayField(TEXT("ResultTableContents"), ResultTableContents);
  
      const TSharedPtr<FJsonObject>* VirtualCurrencyContentsObject;
      if (obj->TryGetObjectField(TEXT("VirtualCurrencyContents"), VirtualCurrencyContentsObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VirtualCurrencyContentsObject)->Values); It; ++It)
          {
              uint32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              VirtualCurrencyContents.Add(It.Key(), TmpValue);
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCatalogItem::~FCatalogItem()
  {
      //if (Bundle != nullptr) delete Bundle;
      //if (Consumable != nullptr) delete Consumable;
      //if (Container != nullptr) delete Container;
  
  }
  
  void PlayFab::ClientModels::FCatalogItem::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Bundle.IsValid()) { writer->WriteIdentifierPrefix(TEXT("Bundle")); Bundle->writeJSON(writer); }
  
      writer->WriteIdentifierPrefix(TEXT("CanBecomeCharacter")); writer->WriteValue(CanBecomeCharacter);
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      if (Consumable.IsValid()) { writer->WriteIdentifierPrefix(TEXT("Consumable")); Consumable->writeJSON(writer); }
  
      if (Container.IsValid()) { writer->WriteIdentifierPrefix(TEXT("Container")); Container->writeJSON(writer); }
  
      if (CustomData.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CustomData")); writer->WriteValue(CustomData); }
  
      if (Description.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Description")); writer->WriteValue(Description); }
  
      if (DisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DisplayName")); writer->WriteValue(DisplayName); }
  
      writer->WriteIdentifierPrefix(TEXT("InitialLimitedEditionCount")); writer->WriteValue(InitialLimitedEditionCount);
  
      writer->WriteIdentifierPrefix(TEXT("IsLimitedEdition")); writer->WriteValue(IsLimitedEdition);
  
      writer->WriteIdentifierPrefix(TEXT("IsStackable")); writer->WriteValue(IsStackable);
  
      writer->WriteIdentifierPrefix(TEXT("IsTradable")); writer->WriteValue(IsTradable);
  
      if (ItemClass.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ItemClass")); writer->WriteValue(ItemClass); }
  
      writer->WriteIdentifierPrefix(TEXT("ItemId")); writer->WriteValue(ItemId);
  
      if (ItemImageUrl.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ItemImageUrl")); writer->WriteValue(ItemImageUrl); }
  
      if (RealCurrencyPrices.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("RealCurrencyPrices"));
          for (TMap<FString, uint32>::TConstIterator It(RealCurrencyPrices); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue(static_cast<int64>((*It).Value));
          }
          writer->WriteObjectEnd();
      }
  
      if (Tags.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Tags"));
          for (const FString& item : Tags)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (VirtualCurrencyPrices.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VirtualCurrencyPrices"));
          for (TMap<FString, uint32>::TConstIterator It(VirtualCurrencyPrices); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue(static_cast<int64>((*It).Value));
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCatalogItem::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> BundleValue = obj->TryGetField(TEXT("Bundle"));
      if (BundleValue.IsValid() && !BundleValue->IsNull())
      {
          Bundle = MakeShareable(new FCatalogItemBundleInfo(BundleValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> CanBecomeCharacterValue = obj->TryGetField(TEXT("CanBecomeCharacter"));
      if (CanBecomeCharacterValue.IsValid() && !CanBecomeCharacterValue->IsNull())
      {
          bool TmpValue;
          if (CanBecomeCharacterValue->TryGetBool(TmpValue)) { CanBecomeCharacter = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ConsumableValue = obj->TryGetField(TEXT("Consumable"));
      if (ConsumableValue.IsValid() && !ConsumableValue->IsNull())
      {
          Consumable = MakeShareable(new FCatalogItemConsumableInfo(ConsumableValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> ContainerValue = obj->TryGetField(TEXT("Container"));
      if (ContainerValue.IsValid() && !ContainerValue->IsNull())
      {
          Container = MakeShareable(new FCatalogItemContainerInfo(ContainerValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> CustomDataValue = obj->TryGetField(TEXT("CustomData"));
      if (CustomDataValue.IsValid() && !CustomDataValue->IsNull())
      {
          FString TmpValue;
          if (CustomDataValue->TryGetString(TmpValue)) { CustomData = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> DescriptionValue = obj->TryGetField(TEXT("Description"));
      if (DescriptionValue.IsValid() && !DescriptionValue->IsNull())
      {
          FString TmpValue;
          if (DescriptionValue->TryGetString(TmpValue)) { Description = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> DisplayNameValue = obj->TryGetField(TEXT("DisplayName"));
      if (DisplayNameValue.IsValid() && !DisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (DisplayNameValue->TryGetString(TmpValue)) { DisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InitialLimitedEditionCountValue = obj->TryGetField(TEXT("InitialLimitedEditionCount"));
      if (InitialLimitedEditionCountValue.IsValid() && !InitialLimitedEditionCountValue->IsNull())
      {
          int32 TmpValue;
          if (InitialLimitedEditionCountValue->TryGetNumber(TmpValue)) { InitialLimitedEditionCount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IsLimitedEditionValue = obj->TryGetField(TEXT("IsLimitedEdition"));
      if (IsLimitedEditionValue.IsValid() && !IsLimitedEditionValue->IsNull())
      {
          bool TmpValue;
          if (IsLimitedEditionValue->TryGetBool(TmpValue)) { IsLimitedEdition = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IsStackableValue = obj->TryGetField(TEXT("IsStackable"));
      if (IsStackableValue.IsValid() && !IsStackableValue->IsNull())
      {
          bool TmpValue;
          if (IsStackableValue->TryGetBool(TmpValue)) { IsStackable = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IsTradableValue = obj->TryGetField(TEXT("IsTradable"));
      if (IsTradableValue.IsValid() && !IsTradableValue->IsNull())
      {
          bool TmpValue;
          if (IsTradableValue->TryGetBool(TmpValue)) { IsTradable = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemClassValue = obj->TryGetField(TEXT("ItemClass"));
      if (ItemClassValue.IsValid() && !ItemClassValue->IsNull())
      {
          FString TmpValue;
          if (ItemClassValue->TryGetString(TmpValue)) { ItemClass = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemIdValue = obj->TryGetField(TEXT("ItemId"));
      if (ItemIdValue.IsValid() && !ItemIdValue->IsNull())
      {
          FString TmpValue;
          if (ItemIdValue->TryGetString(TmpValue)) { ItemId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemImageUrlValue = obj->TryGetField(TEXT("ItemImageUrl"));
      if (ItemImageUrlValue.IsValid() && !ItemImageUrlValue->IsNull())
      {
          FString TmpValue;
          if (ItemImageUrlValue->TryGetString(TmpValue)) { ItemImageUrl = TmpValue; }
      }
  
      const TSharedPtr<FJsonObject>* RealCurrencyPricesObject;
      if (obj->TryGetObjectField(TEXT("RealCurrencyPrices"), RealCurrencyPricesObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*RealCurrencyPricesObject)->Values); It; ++It)
          {
              uint32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              RealCurrencyPrices.Add(It.Key(), TmpValue);
          }
      }
  
      obj->TryGetStringArrayField(TEXT("Tags"), Tags);
  
      const TSharedPtr<FJsonObject>* VirtualCurrencyPricesObject;
      if (obj->TryGetObjectField(TEXT("VirtualCurrencyPrices"), VirtualCurrencyPricesObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VirtualCurrencyPricesObject)->Values); It; ++It)
          {
              uint32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              VirtualCurrencyPrices.Add(It.Key(), TmpValue);
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FItemInstance::~FItemInstance()
  {
  
  }
  
  void PlayFab::ClientModels::FItemInstance::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Annotation.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Annotation")); writer->WriteValue(Annotation); }
  
      if (BundleContents.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("BundleContents"));
          for (const FString& item : BundleContents)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (BundleParent.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("BundleParent")); writer->WriteValue(BundleParent); }
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      if (CustomData.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("CustomData"));
          for (TMap<FString, FString>::TConstIterator It(CustomData); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      if (DisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DisplayName")); writer->WriteValue(DisplayName); }
  
      if (Expiration.notNull()) { writer->WriteIdentifierPrefix(TEXT("Expiration")); writeDatetime(Expiration, writer); }
  
      if (ItemClass.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ItemClass")); writer->WriteValue(ItemClass); }
  
      if (ItemId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ItemId")); writer->WriteValue(ItemId); }
  
      if (ItemInstanceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ItemInstanceId")); writer->WriteValue(ItemInstanceId); }
  
      if (PurchaseDate.notNull()) { writer->WriteIdentifierPrefix(TEXT("PurchaseDate")); writeDatetime(PurchaseDate, writer); }
  
      if (RemainingUses.notNull()) { writer->WriteIdentifierPrefix(TEXT("RemainingUses")); writer->WriteValue(RemainingUses); }
  
      if (UnitCurrency.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("UnitCurrency")); writer->WriteValue(UnitCurrency); }
  
      writer->WriteIdentifierPrefix(TEXT("UnitPrice")); writer->WriteValue(static_cast<int64>(UnitPrice));
  
      if (UsesIncrementedBy.notNull()) { writer->WriteIdentifierPrefix(TEXT("UsesIncrementedBy")); writer->WriteValue(UsesIncrementedBy); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FItemInstance::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AnnotationValue = obj->TryGetField(TEXT("Annotation"));
      if (AnnotationValue.IsValid() && !AnnotationValue->IsNull())
      {
          FString TmpValue;
          if (AnnotationValue->TryGetString(TmpValue)) { Annotation = TmpValue; }
      }
  
      obj->TryGetStringArrayField(TEXT("BundleContents"), BundleContents);
  
      const TSharedPtr<FJsonValue> BundleParentValue = obj->TryGetField(TEXT("BundleParent"));
      if (BundleParentValue.IsValid() && !BundleParentValue->IsNull())
      {
          FString TmpValue;
          if (BundleParentValue->TryGetString(TmpValue)) { BundleParent = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonObject>* CustomDataObject;
      if (obj->TryGetObjectField(TEXT("CustomData"), CustomDataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*CustomDataObject)->Values); It; ++It)
          {
              CustomData.Add(It.Key(), It.Value()->AsString());
          }
      }
  
      const TSharedPtr<FJsonValue> DisplayNameValue = obj->TryGetField(TEXT("DisplayName"));
      if (DisplayNameValue.IsValid() && !DisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (DisplayNameValue->TryGetString(TmpValue)) { DisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ExpirationValue = obj->TryGetField(TEXT("Expiration"));
      if (ExpirationValue.IsValid())
          Expiration = readDatetime(ExpirationValue);
  
  
      const TSharedPtr<FJsonValue> ItemClassValue = obj->TryGetField(TEXT("ItemClass"));
      if (ItemClassValue.IsValid() && !ItemClassValue->IsNull())
      {
          FString TmpValue;
          if (ItemClassValue->TryGetString(TmpValue)) { ItemClass = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemIdValue = obj->TryGetField(TEXT("ItemId"));
      if (ItemIdValue.IsValid() && !ItemIdValue->IsNull())
      {
          FString TmpValue;
          if (ItemIdValue->TryGetString(TmpValue)) { ItemId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemInstanceIdValue = obj->TryGetField(TEXT("ItemInstanceId"));
      if (ItemInstanceIdValue.IsValid() && !ItemInstanceIdValue->IsNull())
      {
          FString TmpValue;
          if (ItemInstanceIdValue->TryGetString(TmpValue)) { ItemInstanceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PurchaseDateValue = obj->TryGetField(TEXT("PurchaseDate"));
      if (PurchaseDateValue.IsValid())
          PurchaseDate = readDatetime(PurchaseDateValue);
  
  
      const TSharedPtr<FJsonValue> RemainingUsesValue = obj->TryGetField(TEXT("RemainingUses"));
      if (RemainingUsesValue.IsValid() && !RemainingUsesValue->IsNull())
      {
          int32 TmpValue;
          if (RemainingUsesValue->TryGetNumber(TmpValue)) { RemainingUses = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UnitCurrencyValue = obj->TryGetField(TEXT("UnitCurrency"));
      if (UnitCurrencyValue.IsValid() && !UnitCurrencyValue->IsNull())
      {
          FString TmpValue;
          if (UnitCurrencyValue->TryGetString(TmpValue)) { UnitCurrency = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UnitPriceValue = obj->TryGetField(TEXT("UnitPrice"));
      if (UnitPriceValue.IsValid() && !UnitPriceValue->IsNull())
      {
          uint32 TmpValue;
          if (UnitPriceValue->TryGetNumber(TmpValue)) { UnitPrice = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UsesIncrementedByValue = obj->TryGetField(TEXT("UsesIncrementedBy"));
      if (UsesIncrementedByValue.IsValid() && !UsesIncrementedByValue->IsNull())
      {
          int32 TmpValue;
          if (UsesIncrementedByValue->TryGetNumber(TmpValue)) { UsesIncrementedBy = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCharacterInventory::~FCharacterInventory()
  {
  
  }
  
  void PlayFab::ClientModels::FCharacterInventory::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      if (Inventory.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Inventory"));
          for (const FItemInstance& item : Inventory)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCharacterInventory::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TArray<TSharedPtr<FJsonValue>>&InventoryArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Inventory"));
      for (int32 Idx = 0; Idx < InventoryArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = InventoryArray[Idx];
          Inventory.Add(FItemInstance(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCharacterLeaderboardEntry::~FCharacterLeaderboardEntry()
  {
  
  }
  
  void PlayFab::ClientModels::FCharacterLeaderboardEntry::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      if (CharacterName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterName")); writer->WriteValue(CharacterName); }
  
      if (CharacterType.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterType")); writer->WriteValue(CharacterType); }
  
      if (DisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DisplayName")); writer->WriteValue(DisplayName); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteIdentifierPrefix(TEXT("Position")); writer->WriteValue(Position);
  
      writer->WriteIdentifierPrefix(TEXT("StatValue")); writer->WriteValue(StatValue);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCharacterLeaderboardEntry::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterNameValue = obj->TryGetField(TEXT("CharacterName"));
      if (CharacterNameValue.IsValid() && !CharacterNameValue->IsNull())
      {
          FString TmpValue;
          if (CharacterNameValue->TryGetString(TmpValue)) { CharacterName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterTypeValue = obj->TryGetField(TEXT("CharacterType"));
      if (CharacterTypeValue.IsValid() && !CharacterTypeValue->IsNull())
      {
          FString TmpValue;
          if (CharacterTypeValue->TryGetString(TmpValue)) { CharacterType = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> DisplayNameValue = obj->TryGetField(TEXT("DisplayName"));
      if (DisplayNameValue.IsValid() && !DisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (DisplayNameValue->TryGetString(TmpValue)) { DisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PositionValue = obj->TryGetField(TEXT("Position"));
      if (PositionValue.IsValid() && !PositionValue->IsNull())
      {
          int32 TmpValue;
          if (PositionValue->TryGetNumber(TmpValue)) { Position = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StatValueValue = obj->TryGetField(TEXT("StatValue"));
      if (StatValueValue.IsValid() && !StatValueValue->IsNull())
      {
          int32 TmpValue;
          if (StatValueValue->TryGetNumber(TmpValue)) { StatValue = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCharacterResult::~FCharacterResult()
  {
  
  }
  
  void PlayFab::ClientModels::FCharacterResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      if (CharacterName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterName")); writer->WriteValue(CharacterName); }
  
      if (CharacterType.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterType")); writer->WriteValue(CharacterType); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCharacterResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterNameValue = obj->TryGetField(TEXT("CharacterName"));
      if (CharacterNameValue.IsValid() && !CharacterNameValue->IsNull())
      {
          FString TmpValue;
          if (CharacterNameValue->TryGetString(TmpValue)) { CharacterName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterTypeValue = obj->TryGetField(TEXT("CharacterType"));
      if (CharacterTypeValue.IsValid() && !CharacterTypeValue->IsNull())
      {
          FString TmpValue;
          if (CharacterTypeValue->TryGetString(TmpValue)) { CharacterType = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeCloudScriptRevisionOptionEnumJSON(CloudScriptRevisionOption enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case CloudScriptRevisionOptionLive: writer->WriteValue(TEXT("Live")); break;
      case CloudScriptRevisionOptionLatest: writer->WriteValue(TEXT("Latest")); break;
      case CloudScriptRevisionOptionSpecific: writer->WriteValue(TEXT("Specific")); break;
      }
  }
  
  ClientModels::CloudScriptRevisionOption PlayFab::ClientModels::readCloudScriptRevisionOptionFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readCloudScriptRevisionOptionFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::CloudScriptRevisionOption PlayFab::ClientModels::readCloudScriptRevisionOptionFromValue(const FString& value)
  {
      static TMap<FString, CloudScriptRevisionOption> _CloudScriptRevisionOptionMap;
      if (_CloudScriptRevisionOptionMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _CloudScriptRevisionOptionMap.Add(TEXT("Live"), CloudScriptRevisionOptionLive);
          _CloudScriptRevisionOptionMap.Add(TEXT("Latest"), CloudScriptRevisionOptionLatest);
          _CloudScriptRevisionOptionMap.Add(TEXT("Specific"), CloudScriptRevisionOptionSpecific);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _CloudScriptRevisionOptionMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return CloudScriptRevisionOptionLive; // Basically critical fail
  }
  
  PlayFab::ClientModels::FContainer_Dictionary_String_String::~FContainer_Dictionary_String_String()
  {
  
  }
  
  void PlayFab::ClientModels::FContainer_Dictionary_String_String::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Data"));
          for (TMap<FString, FString>::TConstIterator It(Data); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FContainer_Dictionary_String_String::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* DataObject;
      if (obj->TryGetObjectField(TEXT("Data"), DataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*DataObject)->Values); It; ++It)
          {
              Data.Add(It.Key(), It.Value()->AsString());
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCollectionFilter::~FCollectionFilter()
  {
  
  }
  
  void PlayFab::ClientModels::FCollectionFilter::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Excludes.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Excludes"));
          for (const FContainer_Dictionary_String_String& item : Excludes)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (Includes.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Includes"));
          for (const FContainer_Dictionary_String_String& item : Includes)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCollectionFilter::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&ExcludesArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Excludes"));
      for (int32 Idx = 0; Idx < ExcludesArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = ExcludesArray[Idx];
          Excludes.Add(FContainer_Dictionary_String_String(CurrentItem->AsObject()));
      }
  
  
      const TArray<TSharedPtr<FJsonValue>>&IncludesArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Includes"));
      for (int32 Idx = 0; Idx < IncludesArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = IncludesArray[Idx];
          Includes.Add(FContainer_Dictionary_String_String(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FConfirmPurchaseRequest::~FConfirmPurchaseRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FConfirmPurchaseRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("OrderId")); writer->WriteValue(OrderId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FConfirmPurchaseRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> OrderIdValue = obj->TryGetField(TEXT("OrderId"));
      if (OrderIdValue.IsValid() && !OrderIdValue->IsNull())
      {
          FString TmpValue;
          if (OrderIdValue->TryGetString(TmpValue)) { OrderId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FConfirmPurchaseResult::~FConfirmPurchaseResult()
  {
  
  }
  
  void PlayFab::ClientModels::FConfirmPurchaseResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Items.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Items"));
          for (const FItemInstance& item : Items)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (OrderId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("OrderId")); writer->WriteValue(OrderId); }
  
      writer->WriteIdentifierPrefix(TEXT("PurchaseDate")); writeDatetime(PurchaseDate, writer);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FConfirmPurchaseResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&ItemsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Items"));
      for (int32 Idx = 0; Idx < ItemsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = ItemsArray[Idx];
          Items.Add(FItemInstance(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> OrderIdValue = obj->TryGetField(TEXT("OrderId"));
      if (OrderIdValue.IsValid() && !OrderIdValue->IsNull())
      {
          FString TmpValue;
          if (OrderIdValue->TryGetString(TmpValue)) { OrderId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PurchaseDateValue = obj->TryGetField(TEXT("PurchaseDate"));
      if (PurchaseDateValue.IsValid())
          PurchaseDate = readDatetime(PurchaseDateValue);
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FConsumeItemRequest::~FConsumeItemRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FConsumeItemRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      writer->WriteIdentifierPrefix(TEXT("ConsumeCount")); writer->WriteValue(ConsumeCount);
  
      writer->WriteIdentifierPrefix(TEXT("ItemInstanceId")); writer->WriteValue(ItemInstanceId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FConsumeItemRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ConsumeCountValue = obj->TryGetField(TEXT("ConsumeCount"));
      if (ConsumeCountValue.IsValid() && !ConsumeCountValue->IsNull())
      {
          int32 TmpValue;
          if (ConsumeCountValue->TryGetNumber(TmpValue)) { ConsumeCount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemInstanceIdValue = obj->TryGetField(TEXT("ItemInstanceId"));
      if (ItemInstanceIdValue.IsValid() && !ItemInstanceIdValue->IsNull())
      {
          FString TmpValue;
          if (ItemInstanceIdValue->TryGetString(TmpValue)) { ItemInstanceId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FConsumeItemResult::~FConsumeItemResult()
  {
  
  }
  
  void PlayFab::ClientModels::FConsumeItemResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ItemInstanceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ItemInstanceId")); writer->WriteValue(ItemInstanceId); }
  
      writer->WriteIdentifierPrefix(TEXT("RemainingUses")); writer->WriteValue(RemainingUses);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FConsumeItemResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ItemInstanceIdValue = obj->TryGetField(TEXT("ItemInstanceId"));
      if (ItemInstanceIdValue.IsValid() && !ItemInstanceIdValue->IsNull())
      {
          FString TmpValue;
          if (ItemInstanceIdValue->TryGetString(TmpValue)) { ItemInstanceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> RemainingUsesValue = obj->TryGetField(TEXT("RemainingUses"));
      if (RemainingUsesValue.IsValid() && !RemainingUsesValue->IsNull())
      {
          int32 TmpValue;
          if (RemainingUsesValue->TryGetNumber(TmpValue)) { RemainingUses = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FConsumePSNEntitlementsRequest::~FConsumePSNEntitlementsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FConsumePSNEntitlementsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      writer->WriteIdentifierPrefix(TEXT("ServiceLabel")); writer->WriteValue(ServiceLabel);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FConsumePSNEntitlementsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServiceLabelValue = obj->TryGetField(TEXT("ServiceLabel"));
      if (ServiceLabelValue.IsValid() && !ServiceLabelValue->IsNull())
      {
          int32 TmpValue;
          if (ServiceLabelValue->TryGetNumber(TmpValue)) { ServiceLabel = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FConsumePSNEntitlementsResult::~FConsumePSNEntitlementsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FConsumePSNEntitlementsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ItemsGranted.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("ItemsGranted"));
          for (const FItemInstance& item : ItemsGranted)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FConsumePSNEntitlementsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&ItemsGrantedArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("ItemsGranted"));
      for (int32 Idx = 0; Idx < ItemsGrantedArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = ItemsGrantedArray[Idx];
          ItemsGranted.Add(FItemInstance(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FConsumeXboxEntitlementsRequest::~FConsumeXboxEntitlementsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FConsumeXboxEntitlementsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      writer->WriteIdentifierPrefix(TEXT("XboxToken")); writer->WriteValue(XboxToken);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FConsumeXboxEntitlementsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> XboxTokenValue = obj->TryGetField(TEXT("XboxToken"));
      if (XboxTokenValue.IsValid() && !XboxTokenValue->IsNull())
      {
          FString TmpValue;
          if (XboxTokenValue->TryGetString(TmpValue)) { XboxToken = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FConsumeXboxEntitlementsResult::~FConsumeXboxEntitlementsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FConsumeXboxEntitlementsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Items.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Items"));
          for (const FItemInstance& item : Items)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FConsumeXboxEntitlementsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&ItemsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Items"));
      for (int32 Idx = 0; Idx < ItemsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = ItemsArray[Idx];
          Items.Add(FItemInstance(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeEmailVerificationStatusEnumJSON(EmailVerificationStatus enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case EmailVerificationStatusUnverified: writer->WriteValue(TEXT("Unverified")); break;
      case EmailVerificationStatusPending: writer->WriteValue(TEXT("Pending")); break;
      case EmailVerificationStatusConfirmed: writer->WriteValue(TEXT("Confirmed")); break;
      }
  }
  
  ClientModels::EmailVerificationStatus PlayFab::ClientModels::readEmailVerificationStatusFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readEmailVerificationStatusFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::EmailVerificationStatus PlayFab::ClientModels::readEmailVerificationStatusFromValue(const FString& value)
  {
      static TMap<FString, EmailVerificationStatus> _EmailVerificationStatusMap;
      if (_EmailVerificationStatusMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _EmailVerificationStatusMap.Add(TEXT("Unverified"), EmailVerificationStatusUnverified);
          _EmailVerificationStatusMap.Add(TEXT("Pending"), EmailVerificationStatusPending);
          _EmailVerificationStatusMap.Add(TEXT("Confirmed"), EmailVerificationStatusConfirmed);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _EmailVerificationStatusMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return EmailVerificationStatusUnverified; // Basically critical fail
  }
  
  PlayFab::ClientModels::FContactEmailInfoModel::~FContactEmailInfoModel()
  {
  
  }
  
  void PlayFab::ClientModels::FContactEmailInfoModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (EmailAddress.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EmailAddress")); writer->WriteValue(EmailAddress); }
  
      if (Name.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Name")); writer->WriteValue(Name); }
  
      if (VerificationStatus.notNull()) { writer->WriteIdentifierPrefix(TEXT("VerificationStatus")); writeEmailVerificationStatusEnumJSON(VerificationStatus, writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FContactEmailInfoModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EmailAddressValue = obj->TryGetField(TEXT("EmailAddress"));
      if (EmailAddressValue.IsValid() && !EmailAddressValue->IsNull())
      {
          FString TmpValue;
          if (EmailAddressValue->TryGetString(TmpValue)) { EmailAddress = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> NameValue = obj->TryGetField(TEXT("Name"));
      if (NameValue.IsValid() && !NameValue->IsNull())
      {
          FString TmpValue;
          if (NameValue->TryGetString(TmpValue)) { Name = TmpValue; }
      }
  
      VerificationStatus = readEmailVerificationStatusFromValue(obj->TryGetField(TEXT("VerificationStatus")));
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeContinentCodeEnumJSON(ContinentCode enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case ContinentCodeAF: writer->WriteValue(TEXT("AF")); break;
      case ContinentCodeAN: writer->WriteValue(TEXT("AN")); break;
      case ContinentCodeAS: writer->WriteValue(TEXT("AS")); break;
      case ContinentCodeEU: writer->WriteValue(TEXT("EU")); break;
      case ContinentCodeNA: writer->WriteValue(TEXT("NA")); break;
      case ContinentCodeOC: writer->WriteValue(TEXT("OC")); break;
      case ContinentCodeSA: writer->WriteValue(TEXT("SA")); break;
      }
  }
  
  ClientModels::ContinentCode PlayFab::ClientModels::readContinentCodeFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readContinentCodeFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::ContinentCode PlayFab::ClientModels::readContinentCodeFromValue(const FString& value)
  {
      static TMap<FString, ContinentCode> _ContinentCodeMap;
      if (_ContinentCodeMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _ContinentCodeMap.Add(TEXT("AF"), ContinentCodeAF);
          _ContinentCodeMap.Add(TEXT("AN"), ContinentCodeAN);
          _ContinentCodeMap.Add(TEXT("AS"), ContinentCodeAS);
          _ContinentCodeMap.Add(TEXT("EU"), ContinentCodeEU);
          _ContinentCodeMap.Add(TEXT("NA"), ContinentCodeNA);
          _ContinentCodeMap.Add(TEXT("OC"), ContinentCodeOC);
          _ContinentCodeMap.Add(TEXT("SA"), ContinentCodeSA);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _ContinentCodeMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return ContinentCodeAF; // Basically critical fail
  }
  
  void PlayFab::ClientModels::writeCountryCodeEnumJSON(CountryCode enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case CountryCodeAF: writer->WriteValue(TEXT("AF")); break;
      case CountryCodeAX: writer->WriteValue(TEXT("AX")); break;
      case CountryCodeAL: writer->WriteValue(TEXT("AL")); break;
      case CountryCodeDZ: writer->WriteValue(TEXT("DZ")); break;
      case CountryCodeAS: writer->WriteValue(TEXT("AS")); break;
      case CountryCodeAD: writer->WriteValue(TEXT("AD")); break;
      case CountryCodeAO: writer->WriteValue(TEXT("AO")); break;
      case CountryCodeAI: writer->WriteValue(TEXT("AI")); break;
      case CountryCodeAQ: writer->WriteValue(TEXT("AQ")); break;
      case CountryCodeAG: writer->WriteValue(TEXT("AG")); break;
      case CountryCodeAR: writer->WriteValue(TEXT("AR")); break;
      case CountryCodeAM: writer->WriteValue(TEXT("AM")); break;
      case CountryCodeAW: writer->WriteValue(TEXT("AW")); break;
      case CountryCodeAU: writer->WriteValue(TEXT("AU")); break;
      case CountryCodeAT: writer->WriteValue(TEXT("AT")); break;
      case CountryCodeAZ: writer->WriteValue(TEXT("AZ")); break;
      case CountryCodeBS: writer->WriteValue(TEXT("BS")); break;
      case CountryCodeBH: writer->WriteValue(TEXT("BH")); break;
      case CountryCodeBD: writer->WriteValue(TEXT("BD")); break;
      case CountryCodeBB: writer->WriteValue(TEXT("BB")); break;
      case CountryCodeBY: writer->WriteValue(TEXT("BY")); break;
      case CountryCodeBE: writer->WriteValue(TEXT("BE")); break;
      case CountryCodeBZ: writer->WriteValue(TEXT("BZ")); break;
      case CountryCodeBJ: writer->WriteValue(TEXT("BJ")); break;
      case CountryCodeBM: writer->WriteValue(TEXT("BM")); break;
      case CountryCodeBT: writer->WriteValue(TEXT("BT")); break;
      case CountryCodeBO: writer->WriteValue(TEXT("BO")); break;
      case CountryCodeBQ: writer->WriteValue(TEXT("BQ")); break;
      case CountryCodeBA: writer->WriteValue(TEXT("BA")); break;
      case CountryCodeBW: writer->WriteValue(TEXT("BW")); break;
      case CountryCodeBV: writer->WriteValue(TEXT("BV")); break;
      case CountryCodeBR: writer->WriteValue(TEXT("BR")); break;
      case CountryCodeIO: writer->WriteValue(TEXT("IO")); break;
      case CountryCodeBN: writer->WriteValue(TEXT("BN")); break;
      case CountryCodeBG: writer->WriteValue(TEXT("BG")); break;
      case CountryCodeBF: writer->WriteValue(TEXT("BF")); break;
      case CountryCodeBI: writer->WriteValue(TEXT("BI")); break;
      case CountryCodeKH: writer->WriteValue(TEXT("KH")); break;
      case CountryCodeCM: writer->WriteValue(TEXT("CM")); break;
      case CountryCodeCA: writer->WriteValue(TEXT("CA")); break;
      case CountryCodeCV: writer->WriteValue(TEXT("CV")); break;
      case CountryCodeKY: writer->WriteValue(TEXT("KY")); break;
      case CountryCodeCF: writer->WriteValue(TEXT("CF")); break;
      case CountryCodeTD: writer->WriteValue(TEXT("TD")); break;
      case CountryCodeCL: writer->WriteValue(TEXT("CL")); break;
      case CountryCodeCN: writer->WriteValue(TEXT("CN")); break;
      case CountryCodeCX: writer->WriteValue(TEXT("CX")); break;
      case CountryCodeCC: writer->WriteValue(TEXT("CC")); break;
      case CountryCodeCO: writer->WriteValue(TEXT("CO")); break;
      case CountryCodeKM: writer->WriteValue(TEXT("KM")); break;
      case CountryCodeCG: writer->WriteValue(TEXT("CG")); break;
      case CountryCodeCD: writer->WriteValue(TEXT("CD")); break;
      case CountryCodeCK: writer->WriteValue(TEXT("CK")); break;
      case CountryCodeCR: writer->WriteValue(TEXT("CR")); break;
      case CountryCodeCI: writer->WriteValue(TEXT("CI")); break;
      case CountryCodeHR: writer->WriteValue(TEXT("HR")); break;
      case CountryCodeCU: writer->WriteValue(TEXT("CU")); break;
      case CountryCodeCW: writer->WriteValue(TEXT("CW")); break;
      case CountryCodeCY: writer->WriteValue(TEXT("CY")); break;
      case CountryCodeCZ: writer->WriteValue(TEXT("CZ")); break;
      case CountryCodeDK: writer->WriteValue(TEXT("DK")); break;
      case CountryCodeDJ: writer->WriteValue(TEXT("DJ")); break;
      case CountryCodeDM: writer->WriteValue(TEXT("DM")); break;
      case CountryCodeDO: writer->WriteValue(TEXT("DO")); break;
      case CountryCodeEC: writer->WriteValue(TEXT("EC")); break;
      case CountryCodeEG: writer->WriteValue(TEXT("EG")); break;
      case CountryCodeSV: writer->WriteValue(TEXT("SV")); break;
      case CountryCodeGQ: writer->WriteValue(TEXT("GQ")); break;
      case CountryCodeER: writer->WriteValue(TEXT("ER")); break;
      case CountryCodeEE: writer->WriteValue(TEXT("EE")); break;
      case CountryCodeET: writer->WriteValue(TEXT("ET")); break;
      case CountryCodeFK: writer->WriteValue(TEXT("FK")); break;
      case CountryCodeFO: writer->WriteValue(TEXT("FO")); break;
      case CountryCodeFJ: writer->WriteValue(TEXT("FJ")); break;
      case CountryCodeFI: writer->WriteValue(TEXT("FI")); break;
      case CountryCodeFR: writer->WriteValue(TEXT("FR")); break;
      case CountryCodeGF: writer->WriteValue(TEXT("GF")); break;
      case CountryCodePF: writer->WriteValue(TEXT("PF")); break;
      case CountryCodeTF: writer->WriteValue(TEXT("TF")); break;
      case CountryCodeGA: writer->WriteValue(TEXT("GA")); break;
      case CountryCodeGM: writer->WriteValue(TEXT("GM")); break;
      case CountryCodeGE: writer->WriteValue(TEXT("GE")); break;
      case CountryCodeDE: writer->WriteValue(TEXT("DE")); break;
      case CountryCodeGH: writer->WriteValue(TEXT("GH")); break;
      case CountryCodeGI: writer->WriteValue(TEXT("GI")); break;
      case CountryCodeGR: writer->WriteValue(TEXT("GR")); break;
      case CountryCodeGL: writer->WriteValue(TEXT("GL")); break;
      case CountryCodeGD: writer->WriteValue(TEXT("GD")); break;
      case CountryCodeGP: writer->WriteValue(TEXT("GP")); break;
      case CountryCodeGU: writer->WriteValue(TEXT("GU")); break;
      case CountryCodeGT: writer->WriteValue(TEXT("GT")); break;
      case CountryCodeGG: writer->WriteValue(TEXT("GG")); break;
      case CountryCodeGN: writer->WriteValue(TEXT("GN")); break;
      case CountryCodeGW: writer->WriteValue(TEXT("GW")); break;
      case CountryCodeGY: writer->WriteValue(TEXT("GY")); break;
      case CountryCodeHT: writer->WriteValue(TEXT("HT")); break;
      case CountryCodeHM: writer->WriteValue(TEXT("HM")); break;
      case CountryCodeVA: writer->WriteValue(TEXT("VA")); break;
      case CountryCodeHN: writer->WriteValue(TEXT("HN")); break;
      case CountryCodeHK: writer->WriteValue(TEXT("HK")); break;
      case CountryCodeHU: writer->WriteValue(TEXT("HU")); break;
      case CountryCodeIS: writer->WriteValue(TEXT("IS")); break;
      case CountryCodeIN: writer->WriteValue(TEXT("IN")); break;
      case CountryCodeID: writer->WriteValue(TEXT("ID")); break;
      case CountryCodeIR: writer->WriteValue(TEXT("IR")); break;
      case CountryCodeIQ: writer->WriteValue(TEXT("IQ")); break;
      case CountryCodeIE: writer->WriteValue(TEXT("IE")); break;
      case CountryCodeIM: writer->WriteValue(TEXT("IM")); break;
      case CountryCodeIL: writer->WriteValue(TEXT("IL")); break;
      case CountryCodeIT: writer->WriteValue(TEXT("IT")); break;
      case CountryCodeJM: writer->WriteValue(TEXT("JM")); break;
      case CountryCodeJP: writer->WriteValue(TEXT("JP")); break;
      case CountryCodeJE: writer->WriteValue(TEXT("JE")); break;
      case CountryCodeJO: writer->WriteValue(TEXT("JO")); break;
      case CountryCodeKZ: writer->WriteValue(TEXT("KZ")); break;
      case CountryCodeKE: writer->WriteValue(TEXT("KE")); break;
      case CountryCodeKI: writer->WriteValue(TEXT("KI")); break;
      case CountryCodeKP: writer->WriteValue(TEXT("KP")); break;
      case CountryCodeKR: writer->WriteValue(TEXT("KR")); break;
      case CountryCodeKW: writer->WriteValue(TEXT("KW")); break;
      case CountryCodeKG: writer->WriteValue(TEXT("KG")); break;
      case CountryCodeLA: writer->WriteValue(TEXT("LA")); break;
      case CountryCodeLV: writer->WriteValue(TEXT("LV")); break;
      case CountryCodeLB: writer->WriteValue(TEXT("LB")); break;
      case CountryCodeLS: writer->WriteValue(TEXT("LS")); break;
      case CountryCodeLR: writer->WriteValue(TEXT("LR")); break;
      case CountryCodeLY: writer->WriteValue(TEXT("LY")); break;
      case CountryCodeLI: writer->WriteValue(TEXT("LI")); break;
      case CountryCodeLT: writer->WriteValue(TEXT("LT")); break;
      case CountryCodeLU: writer->WriteValue(TEXT("LU")); break;
      case CountryCodeMO: writer->WriteValue(TEXT("MO")); break;
      case CountryCodeMK: writer->WriteValue(TEXT("MK")); break;
      case CountryCodeMG: writer->WriteValue(TEXT("MG")); break;
      case CountryCodeMW: writer->WriteValue(TEXT("MW")); break;
      case CountryCodeMY: writer->WriteValue(TEXT("MY")); break;
      case CountryCodeMV: writer->WriteValue(TEXT("MV")); break;
      case CountryCodeML: writer->WriteValue(TEXT("ML")); break;
      case CountryCodeMT: writer->WriteValue(TEXT("MT")); break;
      case CountryCodeMH: writer->WriteValue(TEXT("MH")); break;
      case CountryCodeMQ: writer->WriteValue(TEXT("MQ")); break;
      case CountryCodeMR: writer->WriteValue(TEXT("MR")); break;
      case CountryCodeMU: writer->WriteValue(TEXT("MU")); break;
      case CountryCodeYT: writer->WriteValue(TEXT("YT")); break;
      case CountryCodeMX: writer->WriteValue(TEXT("MX")); break;
      case CountryCodeFM: writer->WriteValue(TEXT("FM")); break;
      case CountryCodeMD: writer->WriteValue(TEXT("MD")); break;
      case CountryCodeMC: writer->WriteValue(TEXT("MC")); break;
      case CountryCodeMN: writer->WriteValue(TEXT("MN")); break;
      case CountryCodeME: writer->WriteValue(TEXT("ME")); break;
      case CountryCodeMS: writer->WriteValue(TEXT("MS")); break;
      case CountryCodeMA: writer->WriteValue(TEXT("MA")); break;
      case CountryCodeMZ: writer->WriteValue(TEXT("MZ")); break;
      case CountryCodeMM: writer->WriteValue(TEXT("MM")); break;
      case CountryCodeNA: writer->WriteValue(TEXT("NA")); break;
      case CountryCodeNR: writer->WriteValue(TEXT("NR")); break;
      case CountryCodeNP: writer->WriteValue(TEXT("NP")); break;
      case CountryCodeNL: writer->WriteValue(TEXT("NL")); break;
      case CountryCodeNC: writer->WriteValue(TEXT("NC")); break;
      case CountryCodeNZ: writer->WriteValue(TEXT("NZ")); break;
      case CountryCodeNI: writer->WriteValue(TEXT("NI")); break;
      case CountryCodeNE: writer->WriteValue(TEXT("NE")); break;
      case CountryCodeNG: writer->WriteValue(TEXT("NG")); break;
      case CountryCodeNU: writer->WriteValue(TEXT("NU")); break;
      case CountryCodeNF: writer->WriteValue(TEXT("NF")); break;
      case CountryCodeMP: writer->WriteValue(TEXT("MP")); break;
      case CountryCodeNO: writer->WriteValue(TEXT("NO")); break;
      case CountryCodeOM: writer->WriteValue(TEXT("OM")); break;
      case CountryCodePK: writer->WriteValue(TEXT("PK")); break;
      case CountryCodePW: writer->WriteValue(TEXT("PW")); break;
      case CountryCodePS: writer->WriteValue(TEXT("PS")); break;
      case CountryCodePA: writer->WriteValue(TEXT("PA")); break;
      case CountryCodePG: writer->WriteValue(TEXT("PG")); break;
      case CountryCodePY: writer->WriteValue(TEXT("PY")); break;
      case CountryCodePE: writer->WriteValue(TEXT("PE")); break;
      case CountryCodePH: writer->WriteValue(TEXT("PH")); break;
      case CountryCodePN: writer->WriteValue(TEXT("PN")); break;
      case CountryCodePL: writer->WriteValue(TEXT("PL")); break;
      case CountryCodePT: writer->WriteValue(TEXT("PT")); break;
      case CountryCodePR: writer->WriteValue(TEXT("PR")); break;
      case CountryCodeQA: writer->WriteValue(TEXT("QA")); break;
      case CountryCodeRE: writer->WriteValue(TEXT("RE")); break;
      case CountryCodeRO: writer->WriteValue(TEXT("RO")); break;
      case CountryCodeRU: writer->WriteValue(TEXT("RU")); break;
      case CountryCodeRW: writer->WriteValue(TEXT("RW")); break;
      case CountryCodeBL: writer->WriteValue(TEXT("BL")); break;
      case CountryCodeSH: writer->WriteValue(TEXT("SH")); break;
      case CountryCodeKN: writer->WriteValue(TEXT("KN")); break;
      case CountryCodeLC: writer->WriteValue(TEXT("LC")); break;
      case CountryCodeMF: writer->WriteValue(TEXT("MF")); break;
      case CountryCodePM: writer->WriteValue(TEXT("PM")); break;
      case CountryCodeVC: writer->WriteValue(TEXT("VC")); break;
      case CountryCodeWS: writer->WriteValue(TEXT("WS")); break;
      case CountryCodeSM: writer->WriteValue(TEXT("SM")); break;
      case CountryCodeST: writer->WriteValue(TEXT("ST")); break;
      case CountryCodeSA: writer->WriteValue(TEXT("SA")); break;
      case CountryCodeSN: writer->WriteValue(TEXT("SN")); break;
      case CountryCodeRS: writer->WriteValue(TEXT("RS")); break;
      case CountryCodeSC: writer->WriteValue(TEXT("SC")); break;
      case CountryCodeSL: writer->WriteValue(TEXT("SL")); break;
      case CountryCodeSG: writer->WriteValue(TEXT("SG")); break;
      case CountryCodeSX: writer->WriteValue(TEXT("SX")); break;
      case CountryCodeSK: writer->WriteValue(TEXT("SK")); break;
      case CountryCodeSI: writer->WriteValue(TEXT("SI")); break;
      case CountryCodeSB: writer->WriteValue(TEXT("SB")); break;
      case CountryCodeSO: writer->WriteValue(TEXT("SO")); break;
      case CountryCodeZA: writer->WriteValue(TEXT("ZA")); break;
      case CountryCodeGS: writer->WriteValue(TEXT("GS")); break;
      case CountryCodeSS: writer->WriteValue(TEXT("SS")); break;
      case CountryCodeES: writer->WriteValue(TEXT("ES")); break;
      case CountryCodeLK: writer->WriteValue(TEXT("LK")); break;
      case CountryCodeSD: writer->WriteValue(TEXT("SD")); break;
      case CountryCodeSR: writer->WriteValue(TEXT("SR")); break;
      case CountryCodeSJ: writer->WriteValue(TEXT("SJ")); break;
      case CountryCodeSZ: writer->WriteValue(TEXT("SZ")); break;
      case CountryCodeSE: writer->WriteValue(TEXT("SE")); break;
      case CountryCodeCH: writer->WriteValue(TEXT("CH")); break;
      case CountryCodeSY: writer->WriteValue(TEXT("SY")); break;
      case CountryCodeTW: writer->WriteValue(TEXT("TW")); break;
      case CountryCodeTJ: writer->WriteValue(TEXT("TJ")); break;
      case CountryCodeTZ: writer->WriteValue(TEXT("TZ")); break;
      case CountryCodeTH: writer->WriteValue(TEXT("TH")); break;
      case CountryCodeTL: writer->WriteValue(TEXT("TL")); break;
      case CountryCodeTG: writer->WriteValue(TEXT("TG")); break;
      case CountryCodeTK: writer->WriteValue(TEXT("TK")); break;
      case CountryCodeTO: writer->WriteValue(TEXT("TO")); break;
      case CountryCodeTT: writer->WriteValue(TEXT("TT")); break;
      case CountryCodeTN: writer->WriteValue(TEXT("TN")); break;
      case CountryCodeTR: writer->WriteValue(TEXT("TR")); break;
      case CountryCodeTM: writer->WriteValue(TEXT("TM")); break;
      case CountryCodeTC: writer->WriteValue(TEXT("TC")); break;
      case CountryCodeTV: writer->WriteValue(TEXT("TV")); break;
      case CountryCodeUG: writer->WriteValue(TEXT("UG")); break;
      case CountryCodeUA: writer->WriteValue(TEXT("UA")); break;
      case CountryCodeAE: writer->WriteValue(TEXT("AE")); break;
      case CountryCodeGB: writer->WriteValue(TEXT("GB")); break;
      case CountryCodeUS: writer->WriteValue(TEXT("US")); break;
      case CountryCodeUM: writer->WriteValue(TEXT("UM")); break;
      case CountryCodeUY: writer->WriteValue(TEXT("UY")); break;
      case CountryCodeUZ: writer->WriteValue(TEXT("UZ")); break;
      case CountryCodeVU: writer->WriteValue(TEXT("VU")); break;
      case CountryCodeVE: writer->WriteValue(TEXT("VE")); break;
      case CountryCodeVN: writer->WriteValue(TEXT("VN")); break;
      case CountryCodeVG: writer->WriteValue(TEXT("VG")); break;
      case CountryCodeVI: writer->WriteValue(TEXT("VI")); break;
      case CountryCodeWF: writer->WriteValue(TEXT("WF")); break;
      case CountryCodeEH: writer->WriteValue(TEXT("EH")); break;
      case CountryCodeYE: writer->WriteValue(TEXT("YE")); break;
      case CountryCodeZM: writer->WriteValue(TEXT("ZM")); break;
      case CountryCodeZW: writer->WriteValue(TEXT("ZW")); break;
      }
  }
  
  ClientModels::CountryCode PlayFab::ClientModels::readCountryCodeFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readCountryCodeFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::CountryCode PlayFab::ClientModels::readCountryCodeFromValue(const FString& value)
  {
      static TMap<FString, CountryCode> _CountryCodeMap;
      if (_CountryCodeMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _CountryCodeMap.Add(TEXT("AF"), CountryCodeAF);
          _CountryCodeMap.Add(TEXT("AX"), CountryCodeAX);
          _CountryCodeMap.Add(TEXT("AL"), CountryCodeAL);
          _CountryCodeMap.Add(TEXT("DZ"), CountryCodeDZ);
          _CountryCodeMap.Add(TEXT("AS"), CountryCodeAS);
          _CountryCodeMap.Add(TEXT("AD"), CountryCodeAD);
          _CountryCodeMap.Add(TEXT("AO"), CountryCodeAO);
          _CountryCodeMap.Add(TEXT("AI"), CountryCodeAI);
          _CountryCodeMap.Add(TEXT("AQ"), CountryCodeAQ);
          _CountryCodeMap.Add(TEXT("AG"), CountryCodeAG);
          _CountryCodeMap.Add(TEXT("AR"), CountryCodeAR);
          _CountryCodeMap.Add(TEXT("AM"), CountryCodeAM);
          _CountryCodeMap.Add(TEXT("AW"), CountryCodeAW);
          _CountryCodeMap.Add(TEXT("AU"), CountryCodeAU);
          _CountryCodeMap.Add(TEXT("AT"), CountryCodeAT);
          _CountryCodeMap.Add(TEXT("AZ"), CountryCodeAZ);
          _CountryCodeMap.Add(TEXT("BS"), CountryCodeBS);
          _CountryCodeMap.Add(TEXT("BH"), CountryCodeBH);
          _CountryCodeMap.Add(TEXT("BD"), CountryCodeBD);
          _CountryCodeMap.Add(TEXT("BB"), CountryCodeBB);
          _CountryCodeMap.Add(TEXT("BY"), CountryCodeBY);
          _CountryCodeMap.Add(TEXT("BE"), CountryCodeBE);
          _CountryCodeMap.Add(TEXT("BZ"), CountryCodeBZ);
          _CountryCodeMap.Add(TEXT("BJ"), CountryCodeBJ);
          _CountryCodeMap.Add(TEXT("BM"), CountryCodeBM);
          _CountryCodeMap.Add(TEXT("BT"), CountryCodeBT);
          _CountryCodeMap.Add(TEXT("BO"), CountryCodeBO);
          _CountryCodeMap.Add(TEXT("BQ"), CountryCodeBQ);
          _CountryCodeMap.Add(TEXT("BA"), CountryCodeBA);
          _CountryCodeMap.Add(TEXT("BW"), CountryCodeBW);
          _CountryCodeMap.Add(TEXT("BV"), CountryCodeBV);
          _CountryCodeMap.Add(TEXT("BR"), CountryCodeBR);
          _CountryCodeMap.Add(TEXT("IO"), CountryCodeIO);
          _CountryCodeMap.Add(TEXT("BN"), CountryCodeBN);
          _CountryCodeMap.Add(TEXT("BG"), CountryCodeBG);
          _CountryCodeMap.Add(TEXT("BF"), CountryCodeBF);
          _CountryCodeMap.Add(TEXT("BI"), CountryCodeBI);
          _CountryCodeMap.Add(TEXT("KH"), CountryCodeKH);
          _CountryCodeMap.Add(TEXT("CM"), CountryCodeCM);
          _CountryCodeMap.Add(TEXT("CA"), CountryCodeCA);
          _CountryCodeMap.Add(TEXT("CV"), CountryCodeCV);
          _CountryCodeMap.Add(TEXT("KY"), CountryCodeKY);
          _CountryCodeMap.Add(TEXT("CF"), CountryCodeCF);
          _CountryCodeMap.Add(TEXT("TD"), CountryCodeTD);
          _CountryCodeMap.Add(TEXT("CL"), CountryCodeCL);
          _CountryCodeMap.Add(TEXT("CN"), CountryCodeCN);
          _CountryCodeMap.Add(TEXT("CX"), CountryCodeCX);
          _CountryCodeMap.Add(TEXT("CC"), CountryCodeCC);
          _CountryCodeMap.Add(TEXT("CO"), CountryCodeCO);
          _CountryCodeMap.Add(TEXT("KM"), CountryCodeKM);
          _CountryCodeMap.Add(TEXT("CG"), CountryCodeCG);
          _CountryCodeMap.Add(TEXT("CD"), CountryCodeCD);
          _CountryCodeMap.Add(TEXT("CK"), CountryCodeCK);
          _CountryCodeMap.Add(TEXT("CR"), CountryCodeCR);
          _CountryCodeMap.Add(TEXT("CI"), CountryCodeCI);
          _CountryCodeMap.Add(TEXT("HR"), CountryCodeHR);
          _CountryCodeMap.Add(TEXT("CU"), CountryCodeCU);
          _CountryCodeMap.Add(TEXT("CW"), CountryCodeCW);
          _CountryCodeMap.Add(TEXT("CY"), CountryCodeCY);
          _CountryCodeMap.Add(TEXT("CZ"), CountryCodeCZ);
          _CountryCodeMap.Add(TEXT("DK"), CountryCodeDK);
          _CountryCodeMap.Add(TEXT("DJ"), CountryCodeDJ);
          _CountryCodeMap.Add(TEXT("DM"), CountryCodeDM);
          _CountryCodeMap.Add(TEXT("DO"), CountryCodeDO);
          _CountryCodeMap.Add(TEXT("EC"), CountryCodeEC);
          _CountryCodeMap.Add(TEXT("EG"), CountryCodeEG);
          _CountryCodeMap.Add(TEXT("SV"), CountryCodeSV);
          _CountryCodeMap.Add(TEXT("GQ"), CountryCodeGQ);
          _CountryCodeMap.Add(TEXT("ER"), CountryCodeER);
          _CountryCodeMap.Add(TEXT("EE"), CountryCodeEE);
          _CountryCodeMap.Add(TEXT("ET"), CountryCodeET);
          _CountryCodeMap.Add(TEXT("FK"), CountryCodeFK);
          _CountryCodeMap.Add(TEXT("FO"), CountryCodeFO);
          _CountryCodeMap.Add(TEXT("FJ"), CountryCodeFJ);
          _CountryCodeMap.Add(TEXT("FI"), CountryCodeFI);
          _CountryCodeMap.Add(TEXT("FR"), CountryCodeFR);
          _CountryCodeMap.Add(TEXT("GF"), CountryCodeGF);
          _CountryCodeMap.Add(TEXT("PF"), CountryCodePF);
          _CountryCodeMap.Add(TEXT("TF"), CountryCodeTF);
          _CountryCodeMap.Add(TEXT("GA"), CountryCodeGA);
          _CountryCodeMap.Add(TEXT("GM"), CountryCodeGM);
          _CountryCodeMap.Add(TEXT("GE"), CountryCodeGE);
          _CountryCodeMap.Add(TEXT("DE"), CountryCodeDE);
          _CountryCodeMap.Add(TEXT("GH"), CountryCodeGH);
          _CountryCodeMap.Add(TEXT("GI"), CountryCodeGI);
          _CountryCodeMap.Add(TEXT("GR"), CountryCodeGR);
          _CountryCodeMap.Add(TEXT("GL"), CountryCodeGL);
          _CountryCodeMap.Add(TEXT("GD"), CountryCodeGD);
          _CountryCodeMap.Add(TEXT("GP"), CountryCodeGP);
          _CountryCodeMap.Add(TEXT("GU"), CountryCodeGU);
          _CountryCodeMap.Add(TEXT("GT"), CountryCodeGT);
          _CountryCodeMap.Add(TEXT("GG"), CountryCodeGG);
          _CountryCodeMap.Add(TEXT("GN"), CountryCodeGN);
          _CountryCodeMap.Add(TEXT("GW"), CountryCodeGW);
          _CountryCodeMap.Add(TEXT("GY"), CountryCodeGY);
          _CountryCodeMap.Add(TEXT("HT"), CountryCodeHT);
          _CountryCodeMap.Add(TEXT("HM"), CountryCodeHM);
          _CountryCodeMap.Add(TEXT("VA"), CountryCodeVA);
          _CountryCodeMap.Add(TEXT("HN"), CountryCodeHN);
          _CountryCodeMap.Add(TEXT("HK"), CountryCodeHK);
          _CountryCodeMap.Add(TEXT("HU"), CountryCodeHU);
          _CountryCodeMap.Add(TEXT("IS"), CountryCodeIS);
          _CountryCodeMap.Add(TEXT("IN"), CountryCodeIN);
          _CountryCodeMap.Add(TEXT("ID"), CountryCodeID);
          _CountryCodeMap.Add(TEXT("IR"), CountryCodeIR);
          _CountryCodeMap.Add(TEXT("IQ"), CountryCodeIQ);
          _CountryCodeMap.Add(TEXT("IE"), CountryCodeIE);
          _CountryCodeMap.Add(TEXT("IM"), CountryCodeIM);
          _CountryCodeMap.Add(TEXT("IL"), CountryCodeIL);
          _CountryCodeMap.Add(TEXT("IT"), CountryCodeIT);
          _CountryCodeMap.Add(TEXT("JM"), CountryCodeJM);
          _CountryCodeMap.Add(TEXT("JP"), CountryCodeJP);
          _CountryCodeMap.Add(TEXT("JE"), CountryCodeJE);
          _CountryCodeMap.Add(TEXT("JO"), CountryCodeJO);
          _CountryCodeMap.Add(TEXT("KZ"), CountryCodeKZ);
          _CountryCodeMap.Add(TEXT("KE"), CountryCodeKE);
          _CountryCodeMap.Add(TEXT("KI"), CountryCodeKI);
          _CountryCodeMap.Add(TEXT("KP"), CountryCodeKP);
          _CountryCodeMap.Add(TEXT("KR"), CountryCodeKR);
          _CountryCodeMap.Add(TEXT("KW"), CountryCodeKW);
          _CountryCodeMap.Add(TEXT("KG"), CountryCodeKG);
          _CountryCodeMap.Add(TEXT("LA"), CountryCodeLA);
          _CountryCodeMap.Add(TEXT("LV"), CountryCodeLV);
          _CountryCodeMap.Add(TEXT("LB"), CountryCodeLB);
          _CountryCodeMap.Add(TEXT("LS"), CountryCodeLS);
          _CountryCodeMap.Add(TEXT("LR"), CountryCodeLR);
          _CountryCodeMap.Add(TEXT("LY"), CountryCodeLY);
          _CountryCodeMap.Add(TEXT("LI"), CountryCodeLI);
          _CountryCodeMap.Add(TEXT("LT"), CountryCodeLT);
          _CountryCodeMap.Add(TEXT("LU"), CountryCodeLU);
          _CountryCodeMap.Add(TEXT("MO"), CountryCodeMO);
          _CountryCodeMap.Add(TEXT("MK"), CountryCodeMK);
          _CountryCodeMap.Add(TEXT("MG"), CountryCodeMG);
          _CountryCodeMap.Add(TEXT("MW"), CountryCodeMW);
          _CountryCodeMap.Add(TEXT("MY"), CountryCodeMY);
          _CountryCodeMap.Add(TEXT("MV"), CountryCodeMV);
          _CountryCodeMap.Add(TEXT("ML"), CountryCodeML);
          _CountryCodeMap.Add(TEXT("MT"), CountryCodeMT);
          _CountryCodeMap.Add(TEXT("MH"), CountryCodeMH);
          _CountryCodeMap.Add(TEXT("MQ"), CountryCodeMQ);
          _CountryCodeMap.Add(TEXT("MR"), CountryCodeMR);
          _CountryCodeMap.Add(TEXT("MU"), CountryCodeMU);
          _CountryCodeMap.Add(TEXT("YT"), CountryCodeYT);
          _CountryCodeMap.Add(TEXT("MX"), CountryCodeMX);
          _CountryCodeMap.Add(TEXT("FM"), CountryCodeFM);
          _CountryCodeMap.Add(TEXT("MD"), CountryCodeMD);
          _CountryCodeMap.Add(TEXT("MC"), CountryCodeMC);
          _CountryCodeMap.Add(TEXT("MN"), CountryCodeMN);
          _CountryCodeMap.Add(TEXT("ME"), CountryCodeME);
          _CountryCodeMap.Add(TEXT("MS"), CountryCodeMS);
          _CountryCodeMap.Add(TEXT("MA"), CountryCodeMA);
          _CountryCodeMap.Add(TEXT("MZ"), CountryCodeMZ);
          _CountryCodeMap.Add(TEXT("MM"), CountryCodeMM);
          _CountryCodeMap.Add(TEXT("NA"), CountryCodeNA);
          _CountryCodeMap.Add(TEXT("NR"), CountryCodeNR);
          _CountryCodeMap.Add(TEXT("NP"), CountryCodeNP);
          _CountryCodeMap.Add(TEXT("NL"), CountryCodeNL);
          _CountryCodeMap.Add(TEXT("NC"), CountryCodeNC);
          _CountryCodeMap.Add(TEXT("NZ"), CountryCodeNZ);
          _CountryCodeMap.Add(TEXT("NI"), CountryCodeNI);
          _CountryCodeMap.Add(TEXT("NE"), CountryCodeNE);
          _CountryCodeMap.Add(TEXT("NG"), CountryCodeNG);
          _CountryCodeMap.Add(TEXT("NU"), CountryCodeNU);
          _CountryCodeMap.Add(TEXT("NF"), CountryCodeNF);
          _CountryCodeMap.Add(TEXT("MP"), CountryCodeMP);
          _CountryCodeMap.Add(TEXT("NO"), CountryCodeNO);
          _CountryCodeMap.Add(TEXT("OM"), CountryCodeOM);
          _CountryCodeMap.Add(TEXT("PK"), CountryCodePK);
          _CountryCodeMap.Add(TEXT("PW"), CountryCodePW);
          _CountryCodeMap.Add(TEXT("PS"), CountryCodePS);
          _CountryCodeMap.Add(TEXT("PA"), CountryCodePA);
          _CountryCodeMap.Add(TEXT("PG"), CountryCodePG);
          _CountryCodeMap.Add(TEXT("PY"), CountryCodePY);
          _CountryCodeMap.Add(TEXT("PE"), CountryCodePE);
          _CountryCodeMap.Add(TEXT("PH"), CountryCodePH);
          _CountryCodeMap.Add(TEXT("PN"), CountryCodePN);
          _CountryCodeMap.Add(TEXT("PL"), CountryCodePL);
          _CountryCodeMap.Add(TEXT("PT"), CountryCodePT);
          _CountryCodeMap.Add(TEXT("PR"), CountryCodePR);
          _CountryCodeMap.Add(TEXT("QA"), CountryCodeQA);
          _CountryCodeMap.Add(TEXT("RE"), CountryCodeRE);
          _CountryCodeMap.Add(TEXT("RO"), CountryCodeRO);
          _CountryCodeMap.Add(TEXT("RU"), CountryCodeRU);
          _CountryCodeMap.Add(TEXT("RW"), CountryCodeRW);
          _CountryCodeMap.Add(TEXT("BL"), CountryCodeBL);
          _CountryCodeMap.Add(TEXT("SH"), CountryCodeSH);
          _CountryCodeMap.Add(TEXT("KN"), CountryCodeKN);
          _CountryCodeMap.Add(TEXT("LC"), CountryCodeLC);
          _CountryCodeMap.Add(TEXT("MF"), CountryCodeMF);
          _CountryCodeMap.Add(TEXT("PM"), CountryCodePM);
          _CountryCodeMap.Add(TEXT("VC"), CountryCodeVC);
          _CountryCodeMap.Add(TEXT("WS"), CountryCodeWS);
          _CountryCodeMap.Add(TEXT("SM"), CountryCodeSM);
          _CountryCodeMap.Add(TEXT("ST"), CountryCodeST);
          _CountryCodeMap.Add(TEXT("SA"), CountryCodeSA);
          _CountryCodeMap.Add(TEXT("SN"), CountryCodeSN);
          _CountryCodeMap.Add(TEXT("RS"), CountryCodeRS);
          _CountryCodeMap.Add(TEXT("SC"), CountryCodeSC);
          _CountryCodeMap.Add(TEXT("SL"), CountryCodeSL);
          _CountryCodeMap.Add(TEXT("SG"), CountryCodeSG);
          _CountryCodeMap.Add(TEXT("SX"), CountryCodeSX);
          _CountryCodeMap.Add(TEXT("SK"), CountryCodeSK);
          _CountryCodeMap.Add(TEXT("SI"), CountryCodeSI);
          _CountryCodeMap.Add(TEXT("SB"), CountryCodeSB);
          _CountryCodeMap.Add(TEXT("SO"), CountryCodeSO);
          _CountryCodeMap.Add(TEXT("ZA"), CountryCodeZA);
          _CountryCodeMap.Add(TEXT("GS"), CountryCodeGS);
          _CountryCodeMap.Add(TEXT("SS"), CountryCodeSS);
          _CountryCodeMap.Add(TEXT("ES"), CountryCodeES);
          _CountryCodeMap.Add(TEXT("LK"), CountryCodeLK);
          _CountryCodeMap.Add(TEXT("SD"), CountryCodeSD);
          _CountryCodeMap.Add(TEXT("SR"), CountryCodeSR);
          _CountryCodeMap.Add(TEXT("SJ"), CountryCodeSJ);
          _CountryCodeMap.Add(TEXT("SZ"), CountryCodeSZ);
          _CountryCodeMap.Add(TEXT("SE"), CountryCodeSE);
          _CountryCodeMap.Add(TEXT("CH"), CountryCodeCH);
          _CountryCodeMap.Add(TEXT("SY"), CountryCodeSY);
          _CountryCodeMap.Add(TEXT("TW"), CountryCodeTW);
          _CountryCodeMap.Add(TEXT("TJ"), CountryCodeTJ);
          _CountryCodeMap.Add(TEXT("TZ"), CountryCodeTZ);
          _CountryCodeMap.Add(TEXT("TH"), CountryCodeTH);
          _CountryCodeMap.Add(TEXT("TL"), CountryCodeTL);
          _CountryCodeMap.Add(TEXT("TG"), CountryCodeTG);
          _CountryCodeMap.Add(TEXT("TK"), CountryCodeTK);
          _CountryCodeMap.Add(TEXT("TO"), CountryCodeTO);
          _CountryCodeMap.Add(TEXT("TT"), CountryCodeTT);
          _CountryCodeMap.Add(TEXT("TN"), CountryCodeTN);
          _CountryCodeMap.Add(TEXT("TR"), CountryCodeTR);
          _CountryCodeMap.Add(TEXT("TM"), CountryCodeTM);
          _CountryCodeMap.Add(TEXT("TC"), CountryCodeTC);
          _CountryCodeMap.Add(TEXT("TV"), CountryCodeTV);
          _CountryCodeMap.Add(TEXT("UG"), CountryCodeUG);
          _CountryCodeMap.Add(TEXT("UA"), CountryCodeUA);
          _CountryCodeMap.Add(TEXT("AE"), CountryCodeAE);
          _CountryCodeMap.Add(TEXT("GB"), CountryCodeGB);
          _CountryCodeMap.Add(TEXT("US"), CountryCodeUS);
          _CountryCodeMap.Add(TEXT("UM"), CountryCodeUM);
          _CountryCodeMap.Add(TEXT("UY"), CountryCodeUY);
          _CountryCodeMap.Add(TEXT("UZ"), CountryCodeUZ);
          _CountryCodeMap.Add(TEXT("VU"), CountryCodeVU);
          _CountryCodeMap.Add(TEXT("VE"), CountryCodeVE);
          _CountryCodeMap.Add(TEXT("VN"), CountryCodeVN);
          _CountryCodeMap.Add(TEXT("VG"), CountryCodeVG);
          _CountryCodeMap.Add(TEXT("VI"), CountryCodeVI);
          _CountryCodeMap.Add(TEXT("WF"), CountryCodeWF);
          _CountryCodeMap.Add(TEXT("EH"), CountryCodeEH);
          _CountryCodeMap.Add(TEXT("YE"), CountryCodeYE);
          _CountryCodeMap.Add(TEXT("ZM"), CountryCodeZM);
          _CountryCodeMap.Add(TEXT("ZW"), CountryCodeZW);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _CountryCodeMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return CountryCodeAF; // Basically critical fail
  }
  
  PlayFab::ClientModels::FCreateSharedGroupRequest::~FCreateSharedGroupRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FCreateSharedGroupRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (SharedGroupId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SharedGroupId")); writer->WriteValue(SharedGroupId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCreateSharedGroupRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> SharedGroupIdValue = obj->TryGetField(TEXT("SharedGroupId"));
      if (SharedGroupIdValue.IsValid() && !SharedGroupIdValue->IsNull())
      {
          FString TmpValue;
          if (SharedGroupIdValue->TryGetString(TmpValue)) { SharedGroupId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCreateSharedGroupResult::~FCreateSharedGroupResult()
  {
  
  }
  
  void PlayFab::ClientModels::FCreateSharedGroupResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (SharedGroupId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SharedGroupId")); writer->WriteValue(SharedGroupId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCreateSharedGroupResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> SharedGroupIdValue = obj->TryGetField(TEXT("SharedGroupId"));
      if (SharedGroupIdValue.IsValid() && !SharedGroupIdValue->IsNull())
      {
          FString TmpValue;
          if (SharedGroupIdValue->TryGetString(TmpValue)) { SharedGroupId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeCurrencyEnumJSON(Currency enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case CurrencyAED: writer->WriteValue(TEXT("AED")); break;
      case CurrencyAFN: writer->WriteValue(TEXT("AFN")); break;
      case CurrencyALL: writer->WriteValue(TEXT("ALL")); break;
      case CurrencyAMD: writer->WriteValue(TEXT("AMD")); break;
      case CurrencyANG: writer->WriteValue(TEXT("ANG")); break;
      case CurrencyAOA: writer->WriteValue(TEXT("AOA")); break;
      case CurrencyARS: writer->WriteValue(TEXT("ARS")); break;
      case CurrencyAUD: writer->WriteValue(TEXT("AUD")); break;
      case CurrencyAWG: writer->WriteValue(TEXT("AWG")); break;
      case CurrencyAZN: writer->WriteValue(TEXT("AZN")); break;
      case CurrencyBAM: writer->WriteValue(TEXT("BAM")); break;
      case CurrencyBBD: writer->WriteValue(TEXT("BBD")); break;
      case CurrencyBDT: writer->WriteValue(TEXT("BDT")); break;
      case CurrencyBGN: writer->WriteValue(TEXT("BGN")); break;
      case CurrencyBHD: writer->WriteValue(TEXT("BHD")); break;
      case CurrencyBIF: writer->WriteValue(TEXT("BIF")); break;
      case CurrencyBMD: writer->WriteValue(TEXT("BMD")); break;
      case CurrencyBND: writer->WriteValue(TEXT("BND")); break;
      case CurrencyBOB: writer->WriteValue(TEXT("BOB")); break;
      case CurrencyBRL: writer->WriteValue(TEXT("BRL")); break;
      case CurrencyBSD: writer->WriteValue(TEXT("BSD")); break;
      case CurrencyBTN: writer->WriteValue(TEXT("BTN")); break;
      case CurrencyBWP: writer->WriteValue(TEXT("BWP")); break;
      case CurrencyBYR: writer->WriteValue(TEXT("BYR")); break;
      case CurrencyBZD: writer->WriteValue(TEXT("BZD")); break;
      case CurrencyCAD: writer->WriteValue(TEXT("CAD")); break;
      case CurrencyCDF: writer->WriteValue(TEXT("CDF")); break;
      case CurrencyCHF: writer->WriteValue(TEXT("CHF")); break;
      case CurrencyCLP: writer->WriteValue(TEXT("CLP")); break;
      case CurrencyCNY: writer->WriteValue(TEXT("CNY")); break;
      case CurrencyCOP: writer->WriteValue(TEXT("COP")); break;
      case CurrencyCRC: writer->WriteValue(TEXT("CRC")); break;
      case CurrencyCUC: writer->WriteValue(TEXT("CUC")); break;
      case CurrencyCUP: writer->WriteValue(TEXT("CUP")); break;
      case CurrencyCVE: writer->WriteValue(TEXT("CVE")); break;
      case CurrencyCZK: writer->WriteValue(TEXT("CZK")); break;
      case CurrencyDJF: writer->WriteValue(TEXT("DJF")); break;
      case CurrencyDKK: writer->WriteValue(TEXT("DKK")); break;
      case CurrencyDOP: writer->WriteValue(TEXT("DOP")); break;
      case CurrencyDZD: writer->WriteValue(TEXT("DZD")); break;
      case CurrencyEGP: writer->WriteValue(TEXT("EGP")); break;
      case CurrencyERN: writer->WriteValue(TEXT("ERN")); break;
      case CurrencyETB: writer->WriteValue(TEXT("ETB")); break;
      case CurrencyEUR: writer->WriteValue(TEXT("EUR")); break;
      case CurrencyFJD: writer->WriteValue(TEXT("FJD")); break;
      case CurrencyFKP: writer->WriteValue(TEXT("FKP")); break;
      case CurrencyGBP: writer->WriteValue(TEXT("GBP")); break;
      case CurrencyGEL: writer->WriteValue(TEXT("GEL")); break;
      case CurrencyGGP: writer->WriteValue(TEXT("GGP")); break;
      case CurrencyGHS: writer->WriteValue(TEXT("GHS")); break;
      case CurrencyGIP: writer->WriteValue(TEXT("GIP")); break;
      case CurrencyGMD: writer->WriteValue(TEXT("GMD")); break;
      case CurrencyGNF: writer->WriteValue(TEXT("GNF")); break;
      case CurrencyGTQ: writer->WriteValue(TEXT("GTQ")); break;
      case CurrencyGYD: writer->WriteValue(TEXT("GYD")); break;
      case CurrencyHKD: writer->WriteValue(TEXT("HKD")); break;
      case CurrencyHNL: writer->WriteValue(TEXT("HNL")); break;
      case CurrencyHRK: writer->WriteValue(TEXT("HRK")); break;
      case CurrencyHTG: writer->WriteValue(TEXT("HTG")); break;
      case CurrencyHUF: writer->WriteValue(TEXT("HUF")); break;
      case CurrencyIDR: writer->WriteValue(TEXT("IDR")); break;
      case CurrencyILS: writer->WriteValue(TEXT("ILS")); break;
      case CurrencyIMP: writer->WriteValue(TEXT("IMP")); break;
      case CurrencyINR: writer->WriteValue(TEXT("INR")); break;
      case CurrencyIQD: writer->WriteValue(TEXT("IQD")); break;
      case CurrencyIRR: writer->WriteValue(TEXT("IRR")); break;
      case CurrencyISK: writer->WriteValue(TEXT("ISK")); break;
      case CurrencyJEP: writer->WriteValue(TEXT("JEP")); break;
      case CurrencyJMD: writer->WriteValue(TEXT("JMD")); break;
      case CurrencyJOD: writer->WriteValue(TEXT("JOD")); break;
      case CurrencyJPY: writer->WriteValue(TEXT("JPY")); break;
      case CurrencyKES: writer->WriteValue(TEXT("KES")); break;
      case CurrencyKGS: writer->WriteValue(TEXT("KGS")); break;
      case CurrencyKHR: writer->WriteValue(TEXT("KHR")); break;
      case CurrencyKMF: writer->WriteValue(TEXT("KMF")); break;
      case CurrencyKPW: writer->WriteValue(TEXT("KPW")); break;
      case CurrencyKRW: writer->WriteValue(TEXT("KRW")); break;
      case CurrencyKWD: writer->WriteValue(TEXT("KWD")); break;
      case CurrencyKYD: writer->WriteValue(TEXT("KYD")); break;
      case CurrencyKZT: writer->WriteValue(TEXT("KZT")); break;
      case CurrencyLAK: writer->WriteValue(TEXT("LAK")); break;
      case CurrencyLBP: writer->WriteValue(TEXT("LBP")); break;
      case CurrencyLKR: writer->WriteValue(TEXT("LKR")); break;
      case CurrencyLRD: writer->WriteValue(TEXT("LRD")); break;
      case CurrencyLSL: writer->WriteValue(TEXT("LSL")); break;
      case CurrencyLYD: writer->WriteValue(TEXT("LYD")); break;
      case CurrencyMAD: writer->WriteValue(TEXT("MAD")); break;
      case CurrencyMDL: writer->WriteValue(TEXT("MDL")); break;
      case CurrencyMGA: writer->WriteValue(TEXT("MGA")); break;
      case CurrencyMKD: writer->WriteValue(TEXT("MKD")); break;
      case CurrencyMMK: writer->WriteValue(TEXT("MMK")); break;
      case CurrencyMNT: writer->WriteValue(TEXT("MNT")); break;
      case CurrencyMOP: writer->WriteValue(TEXT("MOP")); break;
      case CurrencyMRO: writer->WriteValue(TEXT("MRO")); break;
      case CurrencyMUR: writer->WriteValue(TEXT("MUR")); break;
      case CurrencyMVR: writer->WriteValue(TEXT("MVR")); break;
      case CurrencyMWK: writer->WriteValue(TEXT("MWK")); break;
      case CurrencyMXN: writer->WriteValue(TEXT("MXN")); break;
      case CurrencyMYR: writer->WriteValue(TEXT("MYR")); break;
      case CurrencyMZN: writer->WriteValue(TEXT("MZN")); break;
      case CurrencyNAD: writer->WriteValue(TEXT("NAD")); break;
      case CurrencyNGN: writer->WriteValue(TEXT("NGN")); break;
      case CurrencyNIO: writer->WriteValue(TEXT("NIO")); break;
      case CurrencyNOK: writer->WriteValue(TEXT("NOK")); break;
      case CurrencyNPR: writer->WriteValue(TEXT("NPR")); break;
      case CurrencyNZD: writer->WriteValue(TEXT("NZD")); break;
      case CurrencyOMR: writer->WriteValue(TEXT("OMR")); break;
      case CurrencyPAB: writer->WriteValue(TEXT("PAB")); break;
      case CurrencyPEN: writer->WriteValue(TEXT("PEN")); break;
      case CurrencyPGK: writer->WriteValue(TEXT("PGK")); break;
      case CurrencyPHP: writer->WriteValue(TEXT("PHP")); break;
      case CurrencyPKR: writer->WriteValue(TEXT("PKR")); break;
      case CurrencyPLN: writer->WriteValue(TEXT("PLN")); break;
      case CurrencyPYG: writer->WriteValue(TEXT("PYG")); break;
      case CurrencyQAR: writer->WriteValue(TEXT("QAR")); break;
      case CurrencyRON: writer->WriteValue(TEXT("RON")); break;
      case CurrencyRSD: writer->WriteValue(TEXT("RSD")); break;
      case CurrencyRUB: writer->WriteValue(TEXT("RUB")); break;
      case CurrencyRWF: writer->WriteValue(TEXT("RWF")); break;
      case CurrencySAR: writer->WriteValue(TEXT("SAR")); break;
      case CurrencySBD: writer->WriteValue(TEXT("SBD")); break;
      case CurrencySCR: writer->WriteValue(TEXT("SCR")); break;
      case CurrencySDG: writer->WriteValue(TEXT("SDG")); break;
      case CurrencySEK: writer->WriteValue(TEXT("SEK")); break;
      case CurrencySGD: writer->WriteValue(TEXT("SGD")); break;
      case CurrencySHP: writer->WriteValue(TEXT("SHP")); break;
      case CurrencySLL: writer->WriteValue(TEXT("SLL")); break;
      case CurrencySOS: writer->WriteValue(TEXT("SOS")); break;
      case CurrencySPL: writer->WriteValue(TEXT("SPL")); break;
      case CurrencySRD: writer->WriteValue(TEXT("SRD")); break;
      case CurrencySTD: writer->WriteValue(TEXT("STD")); break;
      case CurrencySVC: writer->WriteValue(TEXT("SVC")); break;
      case CurrencySYP: writer->WriteValue(TEXT("SYP")); break;
      case CurrencySZL: writer->WriteValue(TEXT("SZL")); break;
      case CurrencyTHB: writer->WriteValue(TEXT("THB")); break;
      case CurrencyTJS: writer->WriteValue(TEXT("TJS")); break;
      case CurrencyTMT: writer->WriteValue(TEXT("TMT")); break;
      case CurrencyTND: writer->WriteValue(TEXT("TND")); break;
      case CurrencyTOP: writer->WriteValue(TEXT("TOP")); break;
      case CurrencyTRY: writer->WriteValue(TEXT("TRY")); break;
      case CurrencyTTD: writer->WriteValue(TEXT("TTD")); break;
      case CurrencyTVD: writer->WriteValue(TEXT("TVD")); break;
      case CurrencyTWD: writer->WriteValue(TEXT("TWD")); break;
      case CurrencyTZS: writer->WriteValue(TEXT("TZS")); break;
      case CurrencyUAH: writer->WriteValue(TEXT("UAH")); break;
      case CurrencyUGX: writer->WriteValue(TEXT("UGX")); break;
      case CurrencyUSD: writer->WriteValue(TEXT("USD")); break;
      case CurrencyUYU: writer->WriteValue(TEXT("UYU")); break;
      case CurrencyUZS: writer->WriteValue(TEXT("UZS")); break;
      case CurrencyVEF: writer->WriteValue(TEXT("VEF")); break;
      case CurrencyVND: writer->WriteValue(TEXT("VND")); break;
      case CurrencyVUV: writer->WriteValue(TEXT("VUV")); break;
      case CurrencyWST: writer->WriteValue(TEXT("WST")); break;
      case CurrencyXAF: writer->WriteValue(TEXT("XAF")); break;
      case CurrencyXCD: writer->WriteValue(TEXT("XCD")); break;
      case CurrencyXDR: writer->WriteValue(TEXT("XDR")); break;
      case CurrencyXOF: writer->WriteValue(TEXT("XOF")); break;
      case CurrencyXPF: writer->WriteValue(TEXT("XPF")); break;
      case CurrencyYER: writer->WriteValue(TEXT("YER")); break;
      case CurrencyZAR: writer->WriteValue(TEXT("ZAR")); break;
      case CurrencyZMW: writer->WriteValue(TEXT("ZMW")); break;
      case CurrencyZWD: writer->WriteValue(TEXT("ZWD")); break;
      }
  }
  
  ClientModels::Currency PlayFab::ClientModels::readCurrencyFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readCurrencyFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::Currency PlayFab::ClientModels::readCurrencyFromValue(const FString& value)
  {
      static TMap<FString, Currency> _CurrencyMap;
      if (_CurrencyMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _CurrencyMap.Add(TEXT("AED"), CurrencyAED);
          _CurrencyMap.Add(TEXT("AFN"), CurrencyAFN);
          _CurrencyMap.Add(TEXT("ALL"), CurrencyALL);
          _CurrencyMap.Add(TEXT("AMD"), CurrencyAMD);
          _CurrencyMap.Add(TEXT("ANG"), CurrencyANG);
          _CurrencyMap.Add(TEXT("AOA"), CurrencyAOA);
          _CurrencyMap.Add(TEXT("ARS"), CurrencyARS);
          _CurrencyMap.Add(TEXT("AUD"), CurrencyAUD);
          _CurrencyMap.Add(TEXT("AWG"), CurrencyAWG);
          _CurrencyMap.Add(TEXT("AZN"), CurrencyAZN);
          _CurrencyMap.Add(TEXT("BAM"), CurrencyBAM);
          _CurrencyMap.Add(TEXT("BBD"), CurrencyBBD);
          _CurrencyMap.Add(TEXT("BDT"), CurrencyBDT);
          _CurrencyMap.Add(TEXT("BGN"), CurrencyBGN);
          _CurrencyMap.Add(TEXT("BHD"), CurrencyBHD);
          _CurrencyMap.Add(TEXT("BIF"), CurrencyBIF);
          _CurrencyMap.Add(TEXT("BMD"), CurrencyBMD);
          _CurrencyMap.Add(TEXT("BND"), CurrencyBND);
          _CurrencyMap.Add(TEXT("BOB"), CurrencyBOB);
          _CurrencyMap.Add(TEXT("BRL"), CurrencyBRL);
          _CurrencyMap.Add(TEXT("BSD"), CurrencyBSD);
          _CurrencyMap.Add(TEXT("BTN"), CurrencyBTN);
          _CurrencyMap.Add(TEXT("BWP"), CurrencyBWP);
          _CurrencyMap.Add(TEXT("BYR"), CurrencyBYR);
          _CurrencyMap.Add(TEXT("BZD"), CurrencyBZD);
          _CurrencyMap.Add(TEXT("CAD"), CurrencyCAD);
          _CurrencyMap.Add(TEXT("CDF"), CurrencyCDF);
          _CurrencyMap.Add(TEXT("CHF"), CurrencyCHF);
          _CurrencyMap.Add(TEXT("CLP"), CurrencyCLP);
          _CurrencyMap.Add(TEXT("CNY"), CurrencyCNY);
          _CurrencyMap.Add(TEXT("COP"), CurrencyCOP);
          _CurrencyMap.Add(TEXT("CRC"), CurrencyCRC);
          _CurrencyMap.Add(TEXT("CUC"), CurrencyCUC);
          _CurrencyMap.Add(TEXT("CUP"), CurrencyCUP);
          _CurrencyMap.Add(TEXT("CVE"), CurrencyCVE);
          _CurrencyMap.Add(TEXT("CZK"), CurrencyCZK);
          _CurrencyMap.Add(TEXT("DJF"), CurrencyDJF);
          _CurrencyMap.Add(TEXT("DKK"), CurrencyDKK);
          _CurrencyMap.Add(TEXT("DOP"), CurrencyDOP);
          _CurrencyMap.Add(TEXT("DZD"), CurrencyDZD);
          _CurrencyMap.Add(TEXT("EGP"), CurrencyEGP);
          _CurrencyMap.Add(TEXT("ERN"), CurrencyERN);
          _CurrencyMap.Add(TEXT("ETB"), CurrencyETB);
          _CurrencyMap.Add(TEXT("EUR"), CurrencyEUR);
          _CurrencyMap.Add(TEXT("FJD"), CurrencyFJD);
          _CurrencyMap.Add(TEXT("FKP"), CurrencyFKP);
          _CurrencyMap.Add(TEXT("GBP"), CurrencyGBP);
          _CurrencyMap.Add(TEXT("GEL"), CurrencyGEL);
          _CurrencyMap.Add(TEXT("GGP"), CurrencyGGP);
          _CurrencyMap.Add(TEXT("GHS"), CurrencyGHS);
          _CurrencyMap.Add(TEXT("GIP"), CurrencyGIP);
          _CurrencyMap.Add(TEXT("GMD"), CurrencyGMD);
          _CurrencyMap.Add(TEXT("GNF"), CurrencyGNF);
          _CurrencyMap.Add(TEXT("GTQ"), CurrencyGTQ);
          _CurrencyMap.Add(TEXT("GYD"), CurrencyGYD);
          _CurrencyMap.Add(TEXT("HKD"), CurrencyHKD);
          _CurrencyMap.Add(TEXT("HNL"), CurrencyHNL);
          _CurrencyMap.Add(TEXT("HRK"), CurrencyHRK);
          _CurrencyMap.Add(TEXT("HTG"), CurrencyHTG);
          _CurrencyMap.Add(TEXT("HUF"), CurrencyHUF);
          _CurrencyMap.Add(TEXT("IDR"), CurrencyIDR);
          _CurrencyMap.Add(TEXT("ILS"), CurrencyILS);
          _CurrencyMap.Add(TEXT("IMP"), CurrencyIMP);
          _CurrencyMap.Add(TEXT("INR"), CurrencyINR);
          _CurrencyMap.Add(TEXT("IQD"), CurrencyIQD);
          _CurrencyMap.Add(TEXT("IRR"), CurrencyIRR);
          _CurrencyMap.Add(TEXT("ISK"), CurrencyISK);
          _CurrencyMap.Add(TEXT("JEP"), CurrencyJEP);
          _CurrencyMap.Add(TEXT("JMD"), CurrencyJMD);
          _CurrencyMap.Add(TEXT("JOD"), CurrencyJOD);
          _CurrencyMap.Add(TEXT("JPY"), CurrencyJPY);
          _CurrencyMap.Add(TEXT("KES"), CurrencyKES);
          _CurrencyMap.Add(TEXT("KGS"), CurrencyKGS);
          _CurrencyMap.Add(TEXT("KHR"), CurrencyKHR);
          _CurrencyMap.Add(TEXT("KMF"), CurrencyKMF);
          _CurrencyMap.Add(TEXT("KPW"), CurrencyKPW);
          _CurrencyMap.Add(TEXT("KRW"), CurrencyKRW);
          _CurrencyMap.Add(TEXT("KWD"), CurrencyKWD);
          _CurrencyMap.Add(TEXT("KYD"), CurrencyKYD);
          _CurrencyMap.Add(TEXT("KZT"), CurrencyKZT);
          _CurrencyMap.Add(TEXT("LAK"), CurrencyLAK);
          _CurrencyMap.Add(TEXT("LBP"), CurrencyLBP);
          _CurrencyMap.Add(TEXT("LKR"), CurrencyLKR);
          _CurrencyMap.Add(TEXT("LRD"), CurrencyLRD);
          _CurrencyMap.Add(TEXT("LSL"), CurrencyLSL);
          _CurrencyMap.Add(TEXT("LYD"), CurrencyLYD);
          _CurrencyMap.Add(TEXT("MAD"), CurrencyMAD);
          _CurrencyMap.Add(TEXT("MDL"), CurrencyMDL);
          _CurrencyMap.Add(TEXT("MGA"), CurrencyMGA);
          _CurrencyMap.Add(TEXT("MKD"), CurrencyMKD);
          _CurrencyMap.Add(TEXT("MMK"), CurrencyMMK);
          _CurrencyMap.Add(TEXT("MNT"), CurrencyMNT);
          _CurrencyMap.Add(TEXT("MOP"), CurrencyMOP);
          _CurrencyMap.Add(TEXT("MRO"), CurrencyMRO);
          _CurrencyMap.Add(TEXT("MUR"), CurrencyMUR);
          _CurrencyMap.Add(TEXT("MVR"), CurrencyMVR);
          _CurrencyMap.Add(TEXT("MWK"), CurrencyMWK);
          _CurrencyMap.Add(TEXT("MXN"), CurrencyMXN);
          _CurrencyMap.Add(TEXT("MYR"), CurrencyMYR);
          _CurrencyMap.Add(TEXT("MZN"), CurrencyMZN);
          _CurrencyMap.Add(TEXT("NAD"), CurrencyNAD);
          _CurrencyMap.Add(TEXT("NGN"), CurrencyNGN);
          _CurrencyMap.Add(TEXT("NIO"), CurrencyNIO);
          _CurrencyMap.Add(TEXT("NOK"), CurrencyNOK);
          _CurrencyMap.Add(TEXT("NPR"), CurrencyNPR);
          _CurrencyMap.Add(TEXT("NZD"), CurrencyNZD);
          _CurrencyMap.Add(TEXT("OMR"), CurrencyOMR);
          _CurrencyMap.Add(TEXT("PAB"), CurrencyPAB);
          _CurrencyMap.Add(TEXT("PEN"), CurrencyPEN);
          _CurrencyMap.Add(TEXT("PGK"), CurrencyPGK);
          _CurrencyMap.Add(TEXT("PHP"), CurrencyPHP);
          _CurrencyMap.Add(TEXT("PKR"), CurrencyPKR);
          _CurrencyMap.Add(TEXT("PLN"), CurrencyPLN);
          _CurrencyMap.Add(TEXT("PYG"), CurrencyPYG);
          _CurrencyMap.Add(TEXT("QAR"), CurrencyQAR);
          _CurrencyMap.Add(TEXT("RON"), CurrencyRON);
          _CurrencyMap.Add(TEXT("RSD"), CurrencyRSD);
          _CurrencyMap.Add(TEXT("RUB"), CurrencyRUB);
          _CurrencyMap.Add(TEXT("RWF"), CurrencyRWF);
          _CurrencyMap.Add(TEXT("SAR"), CurrencySAR);
          _CurrencyMap.Add(TEXT("SBD"), CurrencySBD);
          _CurrencyMap.Add(TEXT("SCR"), CurrencySCR);
          _CurrencyMap.Add(TEXT("SDG"), CurrencySDG);
          _CurrencyMap.Add(TEXT("SEK"), CurrencySEK);
          _CurrencyMap.Add(TEXT("SGD"), CurrencySGD);
          _CurrencyMap.Add(TEXT("SHP"), CurrencySHP);
          _CurrencyMap.Add(TEXT("SLL"), CurrencySLL);
          _CurrencyMap.Add(TEXT("SOS"), CurrencySOS);
          _CurrencyMap.Add(TEXT("SPL"), CurrencySPL);
          _CurrencyMap.Add(TEXT("SRD"), CurrencySRD);
          _CurrencyMap.Add(TEXT("STD"), CurrencySTD);
          _CurrencyMap.Add(TEXT("SVC"), CurrencySVC);
          _CurrencyMap.Add(TEXT("SYP"), CurrencySYP);
          _CurrencyMap.Add(TEXT("SZL"), CurrencySZL);
          _CurrencyMap.Add(TEXT("THB"), CurrencyTHB);
          _CurrencyMap.Add(TEXT("TJS"), CurrencyTJS);
          _CurrencyMap.Add(TEXT("TMT"), CurrencyTMT);
          _CurrencyMap.Add(TEXT("TND"), CurrencyTND);
          _CurrencyMap.Add(TEXT("TOP"), CurrencyTOP);
          _CurrencyMap.Add(TEXT("TRY"), CurrencyTRY);
          _CurrencyMap.Add(TEXT("TTD"), CurrencyTTD);
          _CurrencyMap.Add(TEXT("TVD"), CurrencyTVD);
          _CurrencyMap.Add(TEXT("TWD"), CurrencyTWD);
          _CurrencyMap.Add(TEXT("TZS"), CurrencyTZS);
          _CurrencyMap.Add(TEXT("UAH"), CurrencyUAH);
          _CurrencyMap.Add(TEXT("UGX"), CurrencyUGX);
          _CurrencyMap.Add(TEXT("USD"), CurrencyUSD);
          _CurrencyMap.Add(TEXT("UYU"), CurrencyUYU);
          _CurrencyMap.Add(TEXT("UZS"), CurrencyUZS);
          _CurrencyMap.Add(TEXT("VEF"), CurrencyVEF);
          _CurrencyMap.Add(TEXT("VND"), CurrencyVND);
          _CurrencyMap.Add(TEXT("VUV"), CurrencyVUV);
          _CurrencyMap.Add(TEXT("WST"), CurrencyWST);
          _CurrencyMap.Add(TEXT("XAF"), CurrencyXAF);
          _CurrencyMap.Add(TEXT("XCD"), CurrencyXCD);
          _CurrencyMap.Add(TEXT("XDR"), CurrencyXDR);
          _CurrencyMap.Add(TEXT("XOF"), CurrencyXOF);
          _CurrencyMap.Add(TEXT("XPF"), CurrencyXPF);
          _CurrencyMap.Add(TEXT("YER"), CurrencyYER);
          _CurrencyMap.Add(TEXT("ZAR"), CurrencyZAR);
          _CurrencyMap.Add(TEXT("ZMW"), CurrencyZMW);
          _CurrencyMap.Add(TEXT("ZWD"), CurrencyZWD);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _CurrencyMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return CurrencyAED; // Basically critical fail
  }
  
  void PlayFab::ClientModels::writeRegionEnumJSON(Region enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case RegionUSCentral: writer->WriteValue(TEXT("USCentral")); break;
      case RegionUSEast: writer->WriteValue(TEXT("USEast")); break;
      case RegionEUWest: writer->WriteValue(TEXT("EUWest")); break;
      case RegionSingapore: writer->WriteValue(TEXT("Singapore")); break;
      case RegionJapan: writer->WriteValue(TEXT("Japan")); break;
      case RegionBrazil: writer->WriteValue(TEXT("Brazil")); break;
      case RegionAustralia: writer->WriteValue(TEXT("Australia")); break;
      }
  }
  
  ClientModels::Region PlayFab::ClientModels::readRegionFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readRegionFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::Region PlayFab::ClientModels::readRegionFromValue(const FString& value)
  {
      static TMap<FString, Region> _RegionMap;
      if (_RegionMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _RegionMap.Add(TEXT("USCentral"), RegionUSCentral);
          _RegionMap.Add(TEXT("USEast"), RegionUSEast);
          _RegionMap.Add(TEXT("EUWest"), RegionEUWest);
          _RegionMap.Add(TEXT("Singapore"), RegionSingapore);
          _RegionMap.Add(TEXT("Japan"), RegionJapan);
          _RegionMap.Add(TEXT("Brazil"), RegionBrazil);
          _RegionMap.Add(TEXT("Australia"), RegionAustralia);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _RegionMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return RegionUSCentral; // Basically critical fail
  }
  
  PlayFab::ClientModels::FCurrentGamesRequest::~FCurrentGamesRequest()
  {
      //if (TagFilter != nullptr) delete TagFilter;
  
  }
  
  void PlayFab::ClientModels::FCurrentGamesRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (BuildVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("BuildVersion")); writer->WriteValue(BuildVersion); }
  
      if (GameMode.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GameMode")); writer->WriteValue(GameMode); }
  
      if (pfRegion.notNull()) { writer->WriteIdentifierPrefix(TEXT("Region")); writeRegionEnumJSON(pfRegion, writer); }
  
      if (StatisticName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName); }
  
      if (TagFilter.IsValid()) { writer->WriteIdentifierPrefix(TEXT("TagFilter")); TagFilter->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCurrentGamesRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> BuildVersionValue = obj->TryGetField(TEXT("BuildVersion"));
      if (BuildVersionValue.IsValid() && !BuildVersionValue->IsNull())
      {
          FString TmpValue;
          if (BuildVersionValue->TryGetString(TmpValue)) { BuildVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GameModeValue = obj->TryGetField(TEXT("GameMode"));
      if (GameModeValue.IsValid() && !GameModeValue->IsNull())
      {
          FString TmpValue;
          if (GameModeValue->TryGetString(TmpValue)) { GameMode = TmpValue; }
      }
  
      pfRegion = readRegionFromValue(obj->TryGetField(TEXT("Region")));
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TagFilterValue = obj->TryGetField(TEXT("TagFilter"));
      if (TagFilterValue.IsValid() && !TagFilterValue->IsNull())
      {
          TagFilter = MakeShareable(new FCollectionFilter(TagFilterValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeGameInstanceStateEnumJSON(GameInstanceState enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case GameInstanceStateOpen: writer->WriteValue(TEXT("Open")); break;
      case GameInstanceStateClosed: writer->WriteValue(TEXT("Closed")); break;
      }
  }
  
  ClientModels::GameInstanceState PlayFab::ClientModels::readGameInstanceStateFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readGameInstanceStateFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::GameInstanceState PlayFab::ClientModels::readGameInstanceStateFromValue(const FString& value)
  {
      static TMap<FString, GameInstanceState> _GameInstanceStateMap;
      if (_GameInstanceStateMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _GameInstanceStateMap.Add(TEXT("Open"), GameInstanceStateOpen);
          _GameInstanceStateMap.Add(TEXT("Closed"), GameInstanceStateClosed);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _GameInstanceStateMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return GameInstanceStateOpen; // Basically critical fail
  }
  
  PlayFab::ClientModels::FGameInfo::~FGameInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FGameInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (BuildVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("BuildVersion")); writer->WriteValue(BuildVersion); }
  
      if (GameMode.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GameMode")); writer->WriteValue(GameMode); }
  
      if (GameServerData.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GameServerData")); writer->WriteValue(GameServerData); }
  
      if (GameServerStateEnum.notNull()) { writer->WriteIdentifierPrefix(TEXT("GameServerStateEnum")); writeGameInstanceStateEnumJSON(GameServerStateEnum, writer); }
  
      if (LastHeartbeat.notNull()) { writer->WriteIdentifierPrefix(TEXT("LastHeartbeat")); writeDatetime(LastHeartbeat, writer); }
  
      if (LobbyID.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("LobbyID")); writer->WriteValue(LobbyID); }
  
      if (MaxPlayers.notNull()) { writer->WriteIdentifierPrefix(TEXT("MaxPlayers")); writer->WriteValue(MaxPlayers); }
  
      if (PlayerUserIds.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("PlayerUserIds"));
          for (const FString& item : PlayerUserIds)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (pfRegion.notNull()) { writer->WriteIdentifierPrefix(TEXT("Region")); writeRegionEnumJSON(pfRegion, writer); }
  
      writer->WriteIdentifierPrefix(TEXT("RunTime")); writer->WriteValue(static_cast<int64>(RunTime));
  
      if (ServerIPV4Address.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ServerIPV4Address")); writer->WriteValue(ServerIPV4Address); }
  
      if (ServerIPV6Address.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ServerIPV6Address")); writer->WriteValue(ServerIPV6Address); }
  
      if (ServerPort.notNull()) { writer->WriteIdentifierPrefix(TEXT("ServerPort")); writer->WriteValue(ServerPort); }
  
      if (ServerPublicDNSName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ServerPublicDNSName")); writer->WriteValue(ServerPublicDNSName); }
  
      if (StatisticName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName); }
  
      if (Tags.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Tags"));
          for (TMap<FString, FString>::TConstIterator It(Tags); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGameInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> BuildVersionValue = obj->TryGetField(TEXT("BuildVersion"));
      if (BuildVersionValue.IsValid() && !BuildVersionValue->IsNull())
      {
          FString TmpValue;
          if (BuildVersionValue->TryGetString(TmpValue)) { BuildVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GameModeValue = obj->TryGetField(TEXT("GameMode"));
      if (GameModeValue.IsValid() && !GameModeValue->IsNull())
      {
          FString TmpValue;
          if (GameModeValue->TryGetString(TmpValue)) { GameMode = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GameServerDataValue = obj->TryGetField(TEXT("GameServerData"));
      if (GameServerDataValue.IsValid() && !GameServerDataValue->IsNull())
      {
          FString TmpValue;
          if (GameServerDataValue->TryGetString(TmpValue)) { GameServerData = TmpValue; }
      }
  
      GameServerStateEnum = readGameInstanceStateFromValue(obj->TryGetField(TEXT("GameServerStateEnum")));
  
      const TSharedPtr<FJsonValue> LastHeartbeatValue = obj->TryGetField(TEXT("LastHeartbeat"));
      if (LastHeartbeatValue.IsValid())
          LastHeartbeat = readDatetime(LastHeartbeatValue);
  
  
      const TSharedPtr<FJsonValue> LobbyIDValue = obj->TryGetField(TEXT("LobbyID"));
      if (LobbyIDValue.IsValid() && !LobbyIDValue->IsNull())
      {
          FString TmpValue;
          if (LobbyIDValue->TryGetString(TmpValue)) { LobbyID = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> MaxPlayersValue = obj->TryGetField(TEXT("MaxPlayers"));
      if (MaxPlayersValue.IsValid() && !MaxPlayersValue->IsNull())
      {
          int32 TmpValue;
          if (MaxPlayersValue->TryGetNumber(TmpValue)) { MaxPlayers = TmpValue; }
      }
  
      obj->TryGetStringArrayField(TEXT("PlayerUserIds"), PlayerUserIds);
  
      pfRegion = readRegionFromValue(obj->TryGetField(TEXT("Region")));
  
      const TSharedPtr<FJsonValue> RunTimeValue = obj->TryGetField(TEXT("RunTime"));
      if (RunTimeValue.IsValid() && !RunTimeValue->IsNull())
      {
          uint32 TmpValue;
          if (RunTimeValue->TryGetNumber(TmpValue)) { RunTime = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerIPV4AddressValue = obj->TryGetField(TEXT("ServerIPV4Address"));
      if (ServerIPV4AddressValue.IsValid() && !ServerIPV4AddressValue->IsNull())
      {
          FString TmpValue;
          if (ServerIPV4AddressValue->TryGetString(TmpValue)) { ServerIPV4Address = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerIPV6AddressValue = obj->TryGetField(TEXT("ServerIPV6Address"));
      if (ServerIPV6AddressValue.IsValid() && !ServerIPV6AddressValue->IsNull())
      {
          FString TmpValue;
          if (ServerIPV6AddressValue->TryGetString(TmpValue)) { ServerIPV6Address = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerPortValue = obj->TryGetField(TEXT("ServerPort"));
      if (ServerPortValue.IsValid() && !ServerPortValue->IsNull())
      {
          int32 TmpValue;
          if (ServerPortValue->TryGetNumber(TmpValue)) { ServerPort = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerPublicDNSNameValue = obj->TryGetField(TEXT("ServerPublicDNSName"));
      if (ServerPublicDNSNameValue.IsValid() && !ServerPublicDNSNameValue->IsNull())
      {
          FString TmpValue;
          if (ServerPublicDNSNameValue->TryGetString(TmpValue)) { ServerPublicDNSName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      const TSharedPtr<FJsonObject>* TagsObject;
      if (obj->TryGetObjectField(TEXT("Tags"), TagsObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*TagsObject)->Values); It; ++It)
          {
              Tags.Add(It.Key(), It.Value()->AsString());
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FCurrentGamesResult::~FCurrentGamesResult()
  {
  
  }
  
  void PlayFab::ClientModels::FCurrentGamesResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("GameCount")); writer->WriteValue(GameCount);
  
      if (Games.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Games"));
          for (const FGameInfo& item : Games)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteIdentifierPrefix(TEXT("PlayerCount")); writer->WriteValue(PlayerCount);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FCurrentGamesResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> GameCountValue = obj->TryGetField(TEXT("GameCount"));
      if (GameCountValue.IsValid() && !GameCountValue->IsNull())
      {
          int32 TmpValue;
          if (GameCountValue->TryGetNumber(TmpValue)) { GameCount = TmpValue; }
      }
  
      const TArray<TSharedPtr<FJsonValue>>&GamesArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Games"));
      for (int32 Idx = 0; Idx < GamesArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = GamesArray[Idx];
          Games.Add(FGameInfo(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> PlayerCountValue = obj->TryGetField(TEXT("PlayerCount"));
      if (PlayerCountValue.IsValid() && !PlayerCountValue->IsNull())
      {
          int32 TmpValue;
          if (PlayerCountValue->TryGetNumber(TmpValue)) { PlayerCount = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FDeviceInfoRequest::~FDeviceInfoRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FDeviceInfoRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Info.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Info"));
          for (TMap<FString, FJsonKeeper>::TConstIterator It(Info); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FDeviceInfoRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* InfoObject;
      if (obj->TryGetObjectField(TEXT("Info"), InfoObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*InfoObject)->Values); It; ++It)
          {
              Info.Add(It.Key(), FJsonKeeper(It.Value()));
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FEmptyResponse::~FEmptyResponse()
  {
  
  }
  
  void PlayFab::ClientModels::FEmptyResponse::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FEmptyResponse::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FEmptyResult::~FEmptyResult()
  {
  
  }
  
  void PlayFab::ClientModels::FEmptyResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FEmptyResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FEntityKey::~FEntityKey()
  {
  
  }
  
  void PlayFab::ClientModels::FEntityKey::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Id")); writer->WriteValue(Id);
  
      if (Type.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Type")); writer->WriteValue(Type); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FEntityKey::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> IdValue = obj->TryGetField(TEXT("Id"));
      if (IdValue.IsValid() && !IdValue->IsNull())
      {
          FString TmpValue;
          if (IdValue->TryGetString(TmpValue)) { Id = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TypeValue = obj->TryGetField(TEXT("Type"));
      if (TypeValue.IsValid() && !TypeValue->IsNull())
      {
          FString TmpValue;
          if (TypeValue->TryGetString(TmpValue)) { Type = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FEntityTokenResponse::~FEntityTokenResponse()
  {
      //if (Entity != nullptr) delete Entity;
  
  }
  
  void PlayFab::ClientModels::FEntityTokenResponse::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Entity.IsValid()) { writer->WriteIdentifierPrefix(TEXT("Entity")); Entity->writeJSON(writer); }
  
      if (EntityToken.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EntityToken")); writer->WriteValue(EntityToken); }
  
      if (TokenExpiration.notNull()) { writer->WriteIdentifierPrefix(TEXT("TokenExpiration")); writeDatetime(TokenExpiration, writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FEntityTokenResponse::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EntityValue = obj->TryGetField(TEXT("Entity"));
      if (EntityValue.IsValid() && !EntityValue->IsNull())
      {
          Entity = MakeShareable(new FEntityKey(EntityValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> EntityTokenValue = obj->TryGetField(TEXT("EntityToken"));
      if (EntityTokenValue.IsValid() && !EntityTokenValue->IsNull())
      {
          FString TmpValue;
          if (EntityTokenValue->TryGetString(TmpValue)) { EntityToken = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TokenExpirationValue = obj->TryGetField(TEXT("TokenExpiration"));
      if (TokenExpirationValue.IsValid())
          TokenExpiration = readDatetime(TokenExpirationValue);
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FExecuteCloudScriptRequest::~FExecuteCloudScriptRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FExecuteCloudScriptRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("FunctionName")); writer->WriteValue(FunctionName);
  
      if (FunctionParameter.notNull()) { writer->WriteIdentifierPrefix(TEXT("FunctionParameter")); FunctionParameter.writeJSON(writer); }
  
      if (GeneratePlayStreamEvent.notNull()) { writer->WriteIdentifierPrefix(TEXT("GeneratePlayStreamEvent")); writer->WriteValue(GeneratePlayStreamEvent); }
  
      if (RevisionSelection.notNull()) { writer->WriteIdentifierPrefix(TEXT("RevisionSelection")); writeCloudScriptRevisionOptionEnumJSON(RevisionSelection, writer); }
  
      if (SpecificRevision.notNull()) { writer->WriteIdentifierPrefix(TEXT("SpecificRevision")); writer->WriteValue(SpecificRevision); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FExecuteCloudScriptRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> FunctionNameValue = obj->TryGetField(TEXT("FunctionName"));
      if (FunctionNameValue.IsValid() && !FunctionNameValue->IsNull())
      {
          FString TmpValue;
          if (FunctionNameValue->TryGetString(TmpValue)) { FunctionName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> FunctionParameterValue = obj->TryGetField(TEXT("FunctionParameter"));
      if (FunctionParameterValue.IsValid() && !FunctionParameterValue->IsNull())
      {
          FunctionParameter = FJsonKeeper(FunctionParameterValue);
      }
  
      const TSharedPtr<FJsonValue> GeneratePlayStreamEventValue = obj->TryGetField(TEXT("GeneratePlayStreamEvent"));
      if (GeneratePlayStreamEventValue.IsValid() && !GeneratePlayStreamEventValue->IsNull())
      {
          bool TmpValue;
          if (GeneratePlayStreamEventValue->TryGetBool(TmpValue)) { GeneratePlayStreamEvent = TmpValue; }
      }
  
      RevisionSelection = readCloudScriptRevisionOptionFromValue(obj->TryGetField(TEXT("RevisionSelection")));
  
      const TSharedPtr<FJsonValue> SpecificRevisionValue = obj->TryGetField(TEXT("SpecificRevision"));
      if (SpecificRevisionValue.IsValid() && !SpecificRevisionValue->IsNull())
      {
          int32 TmpValue;
          if (SpecificRevisionValue->TryGetNumber(TmpValue)) { SpecificRevision = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FScriptExecutionError::~FScriptExecutionError()
  {
  
  }
  
  void PlayFab::ClientModels::FScriptExecutionError::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Error.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Error")); writer->WriteValue(Error); }
  
      if (Message.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Message")); writer->WriteValue(Message); }
  
      if (StackTrace.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("StackTrace")); writer->WriteValue(StackTrace); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FScriptExecutionError::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ErrorValue = obj->TryGetField(TEXT("Error"));
      if (ErrorValue.IsValid() && !ErrorValue->IsNull())
      {
          FString TmpValue;
          if (ErrorValue->TryGetString(TmpValue)) { Error = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> MessageValue = obj->TryGetField(TEXT("Message"));
      if (MessageValue.IsValid() && !MessageValue->IsNull())
      {
          FString TmpValue;
          if (MessageValue->TryGetString(TmpValue)) { Message = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StackTraceValue = obj->TryGetField(TEXT("StackTrace"));
      if (StackTraceValue.IsValid() && !StackTraceValue->IsNull())
      {
          FString TmpValue;
          if (StackTraceValue->TryGetString(TmpValue)) { StackTrace = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLogStatement::~FLogStatement()
  {
  
  }
  
  void PlayFab::ClientModels::FLogStatement::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.notNull()) { writer->WriteIdentifierPrefix(TEXT("Data")); Data.writeJSON(writer); }
  
      if (Level.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Level")); writer->WriteValue(Level); }
  
      if (Message.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Message")); writer->WriteValue(Message); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLogStatement::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DataValue = obj->TryGetField(TEXT("Data"));
      if (DataValue.IsValid() && !DataValue->IsNull())
      {
          Data = FJsonKeeper(DataValue);
      }
  
      const TSharedPtr<FJsonValue> LevelValue = obj->TryGetField(TEXT("Level"));
      if (LevelValue.IsValid() && !LevelValue->IsNull())
      {
          FString TmpValue;
          if (LevelValue->TryGetString(TmpValue)) { Level = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> MessageValue = obj->TryGetField(TEXT("Message"));
      if (MessageValue.IsValid() && !MessageValue->IsNull())
      {
          FString TmpValue;
          if (MessageValue->TryGetString(TmpValue)) { Message = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FExecuteCloudScriptResult::~FExecuteCloudScriptResult()
  {
      //if (Error != nullptr) delete Error;
  
  }
  
  void PlayFab::ClientModels::FExecuteCloudScriptResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("APIRequestsIssued")); writer->WriteValue(APIRequestsIssued);
  
      if (Error.IsValid()) { writer->WriteIdentifierPrefix(TEXT("Error")); Error->writeJSON(writer); }
  
      writer->WriteIdentifierPrefix(TEXT("ExecutionTimeSeconds")); writer->WriteValue(ExecutionTimeSeconds);
  
      if (FunctionName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FunctionName")); writer->WriteValue(FunctionName); }
  
      if (FunctionResult.notNull()) { writer->WriteIdentifierPrefix(TEXT("FunctionResult")); FunctionResult.writeJSON(writer); }
  
      if (FunctionResultTooLarge.notNull()) { writer->WriteIdentifierPrefix(TEXT("FunctionResultTooLarge")); writer->WriteValue(FunctionResultTooLarge); }
  
      writer->WriteIdentifierPrefix(TEXT("HttpRequestsIssued")); writer->WriteValue(HttpRequestsIssued);
  
      if (Logs.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Logs"));
          for (const FLogStatement& item : Logs)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (LogsTooLarge.notNull()) { writer->WriteIdentifierPrefix(TEXT("LogsTooLarge")); writer->WriteValue(LogsTooLarge); }
  
      writer->WriteIdentifierPrefix(TEXT("MemoryConsumedBytes")); writer->WriteValue(static_cast<int64>(MemoryConsumedBytes));
  
      writer->WriteIdentifierPrefix(TEXT("ProcessorTimeSeconds")); writer->WriteValue(ProcessorTimeSeconds);
  
      writer->WriteIdentifierPrefix(TEXT("Revision")); writer->WriteValue(Revision);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FExecuteCloudScriptResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> APIRequestsIssuedValue = obj->TryGetField(TEXT("APIRequestsIssued"));
      if (APIRequestsIssuedValue.IsValid() && !APIRequestsIssuedValue->IsNull())
      {
          int32 TmpValue;
          if (APIRequestsIssuedValue->TryGetNumber(TmpValue)) { APIRequestsIssued = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ErrorValue = obj->TryGetField(TEXT("Error"));
      if (ErrorValue.IsValid() && !ErrorValue->IsNull())
      {
          Error = MakeShareable(new FScriptExecutionError(ErrorValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> ExecutionTimeSecondsValue = obj->TryGetField(TEXT("ExecutionTimeSeconds"));
      if (ExecutionTimeSecondsValue.IsValid() && !ExecutionTimeSecondsValue->IsNull())
      {
          double TmpValue;
          if (ExecutionTimeSecondsValue->TryGetNumber(TmpValue)) { ExecutionTimeSeconds = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> FunctionNameValue = obj->TryGetField(TEXT("FunctionName"));
      if (FunctionNameValue.IsValid() && !FunctionNameValue->IsNull())
      {
          FString TmpValue;
          if (FunctionNameValue->TryGetString(TmpValue)) { FunctionName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> FunctionResultValue = obj->TryGetField(TEXT("FunctionResult"));
      if (FunctionResultValue.IsValid() && !FunctionResultValue->IsNull())
      {
          FunctionResult = FJsonKeeper(FunctionResultValue);
      }
  
      const TSharedPtr<FJsonValue> FunctionResultTooLargeValue = obj->TryGetField(TEXT("FunctionResultTooLarge"));
      if (FunctionResultTooLargeValue.IsValid() && !FunctionResultTooLargeValue->IsNull())
      {
          bool TmpValue;
          if (FunctionResultTooLargeValue->TryGetBool(TmpValue)) { FunctionResultTooLarge = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> HttpRequestsIssuedValue = obj->TryGetField(TEXT("HttpRequestsIssued"));
      if (HttpRequestsIssuedValue.IsValid() && !HttpRequestsIssuedValue->IsNull())
      {
          int32 TmpValue;
          if (HttpRequestsIssuedValue->TryGetNumber(TmpValue)) { HttpRequestsIssued = TmpValue; }
      }
  
      const TArray<TSharedPtr<FJsonValue>>&LogsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Logs"));
      for (int32 Idx = 0; Idx < LogsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = LogsArray[Idx];
          Logs.Add(FLogStatement(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> LogsTooLargeValue = obj->TryGetField(TEXT("LogsTooLarge"));
      if (LogsTooLargeValue.IsValid() && !LogsTooLargeValue->IsNull())
      {
          bool TmpValue;
          if (LogsTooLargeValue->TryGetBool(TmpValue)) { LogsTooLarge = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> MemoryConsumedBytesValue = obj->TryGetField(TEXT("MemoryConsumedBytes"));
      if (MemoryConsumedBytesValue.IsValid() && !MemoryConsumedBytesValue->IsNull())
      {
          uint32 TmpValue;
          if (MemoryConsumedBytesValue->TryGetNumber(TmpValue)) { MemoryConsumedBytes = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProcessorTimeSecondsValue = obj->TryGetField(TEXT("ProcessorTimeSeconds"));
      if (ProcessorTimeSecondsValue.IsValid() && !ProcessorTimeSecondsValue->IsNull())
      {
          double TmpValue;
          if (ProcessorTimeSecondsValue->TryGetNumber(TmpValue)) { ProcessorTimeSeconds = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> RevisionValue = obj->TryGetField(TEXT("Revision"));
      if (RevisionValue.IsValid() && !RevisionValue->IsNull())
      {
          int32 TmpValue;
          if (RevisionValue->TryGetNumber(TmpValue)) { Revision = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FFacebookInstantGamesPlayFabIdPair::~FFacebookInstantGamesPlayFabIdPair()
  {
  
  }
  
  void PlayFab::ClientModels::FFacebookInstantGamesPlayFabIdPair::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (FacebookInstantGamesId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FacebookInstantGamesId")); writer->WriteValue(FacebookInstantGamesId); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FFacebookInstantGamesPlayFabIdPair::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> FacebookInstantGamesIdValue = obj->TryGetField(TEXT("FacebookInstantGamesId"));
      if (FacebookInstantGamesIdValue.IsValid() && !FacebookInstantGamesIdValue->IsNull())
      {
          FString TmpValue;
          if (FacebookInstantGamesIdValue->TryGetString(TmpValue)) { FacebookInstantGamesId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FFacebookPlayFabIdPair::~FFacebookPlayFabIdPair()
  {
  
  }
  
  void PlayFab::ClientModels::FFacebookPlayFabIdPair::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (FacebookId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FacebookId")); writer->WriteValue(FacebookId); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FFacebookPlayFabIdPair::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> FacebookIdValue = obj->TryGetField(TEXT("FacebookId"));
      if (FacebookIdValue.IsValid() && !FacebookIdValue->IsNull())
      {
          FString TmpValue;
          if (FacebookIdValue->TryGetString(TmpValue)) { FacebookId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserFacebookInfo::~FUserFacebookInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserFacebookInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (FacebookId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FacebookId")); writer->WriteValue(FacebookId); }
  
      if (FullName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FullName")); writer->WriteValue(FullName); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserFacebookInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> FacebookIdValue = obj->TryGetField(TEXT("FacebookId"));
      if (FacebookIdValue.IsValid() && !FacebookIdValue->IsNull())
      {
          FString TmpValue;
          if (FacebookIdValue->TryGetString(TmpValue)) { FacebookId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> FullNameValue = obj->TryGetField(TEXT("FullName"));
      if (FullNameValue.IsValid() && !FullNameValue->IsNull())
      {
          FString TmpValue;
          if (FullNameValue->TryGetString(TmpValue)) { FullName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserGameCenterInfo::~FUserGameCenterInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserGameCenterInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (GameCenterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GameCenterId")); writer->WriteValue(GameCenterId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserGameCenterInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> GameCenterIdValue = obj->TryGetField(TEXT("GameCenterId"));
      if (GameCenterIdValue.IsValid() && !GameCenterIdValue->IsNull())
      {
          FString TmpValue;
          if (GameCenterIdValue->TryGetString(TmpValue)) { GameCenterId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeLoginIdentityProviderEnumJSON(LoginIdentityProvider enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case LoginIdentityProviderUnknown: writer->WriteValue(TEXT("Unknown")); break;
      case LoginIdentityProviderPlayFab: writer->WriteValue(TEXT("PlayFab")); break;
      case LoginIdentityProviderCustom: writer->WriteValue(TEXT("Custom")); break;
      case LoginIdentityProviderGameCenter: writer->WriteValue(TEXT("GameCenter")); break;
      case LoginIdentityProviderGooglePlay: writer->WriteValue(TEXT("GooglePlay")); break;
      case LoginIdentityProviderSteam: writer->WriteValue(TEXT("Steam")); break;
      case LoginIdentityProviderXBoxLive: writer->WriteValue(TEXT("XBoxLive")); break;
      case LoginIdentityProviderPSN: writer->WriteValue(TEXT("PSN")); break;
      case LoginIdentityProviderKongregate: writer->WriteValue(TEXT("Kongregate")); break;
      case LoginIdentityProviderFacebook: writer->WriteValue(TEXT("Facebook")); break;
      case LoginIdentityProviderIOSDevice: writer->WriteValue(TEXT("IOSDevice")); break;
      case LoginIdentityProviderAndroidDevice: writer->WriteValue(TEXT("AndroidDevice")); break;
      case LoginIdentityProviderTwitch: writer->WriteValue(TEXT("Twitch")); break;
      case LoginIdentityProviderWindowsHello: writer->WriteValue(TEXT("WindowsHello")); break;
      case LoginIdentityProviderGameServer: writer->WriteValue(TEXT("GameServer")); break;
      case LoginIdentityProviderCustomServer: writer->WriteValue(TEXT("CustomServer")); break;
      case LoginIdentityProviderNintendoSwitch: writer->WriteValue(TEXT("NintendoSwitch")); break;
      case LoginIdentityProviderFacebookInstantGames: writer->WriteValue(TEXT("FacebookInstantGames")); break;
      case LoginIdentityProviderOpenIdConnect: writer->WriteValue(TEXT("OpenIdConnect")); break;
      }
  }
  
  ClientModels::LoginIdentityProvider PlayFab::ClientModels::readLoginIdentityProviderFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readLoginIdentityProviderFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::LoginIdentityProvider PlayFab::ClientModels::readLoginIdentityProviderFromValue(const FString& value)
  {
      static TMap<FString, LoginIdentityProvider> _LoginIdentityProviderMap;
      if (_LoginIdentityProviderMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _LoginIdentityProviderMap.Add(TEXT("Unknown"), LoginIdentityProviderUnknown);
          _LoginIdentityProviderMap.Add(TEXT("PlayFab"), LoginIdentityProviderPlayFab);
          _LoginIdentityProviderMap.Add(TEXT("Custom"), LoginIdentityProviderCustom);
          _LoginIdentityProviderMap.Add(TEXT("GameCenter"), LoginIdentityProviderGameCenter);
          _LoginIdentityProviderMap.Add(TEXT("GooglePlay"), LoginIdentityProviderGooglePlay);
          _LoginIdentityProviderMap.Add(TEXT("Steam"), LoginIdentityProviderSteam);
          _LoginIdentityProviderMap.Add(TEXT("XBoxLive"), LoginIdentityProviderXBoxLive);
          _LoginIdentityProviderMap.Add(TEXT("PSN"), LoginIdentityProviderPSN);
          _LoginIdentityProviderMap.Add(TEXT("Kongregate"), LoginIdentityProviderKongregate);
          _LoginIdentityProviderMap.Add(TEXT("Facebook"), LoginIdentityProviderFacebook);
          _LoginIdentityProviderMap.Add(TEXT("IOSDevice"), LoginIdentityProviderIOSDevice);
          _LoginIdentityProviderMap.Add(TEXT("AndroidDevice"), LoginIdentityProviderAndroidDevice);
          _LoginIdentityProviderMap.Add(TEXT("Twitch"), LoginIdentityProviderTwitch);
          _LoginIdentityProviderMap.Add(TEXT("WindowsHello"), LoginIdentityProviderWindowsHello);
          _LoginIdentityProviderMap.Add(TEXT("GameServer"), LoginIdentityProviderGameServer);
          _LoginIdentityProviderMap.Add(TEXT("CustomServer"), LoginIdentityProviderCustomServer);
          _LoginIdentityProviderMap.Add(TEXT("NintendoSwitch"), LoginIdentityProviderNintendoSwitch);
          _LoginIdentityProviderMap.Add(TEXT("FacebookInstantGames"), LoginIdentityProviderFacebookInstantGames);
          _LoginIdentityProviderMap.Add(TEXT("OpenIdConnect"), LoginIdentityProviderOpenIdConnect);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _LoginIdentityProviderMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return LoginIdentityProviderUnknown; // Basically critical fail
  }
  
  PlayFab::ClientModels::FLinkedPlatformAccountModel::~FLinkedPlatformAccountModel()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkedPlatformAccountModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Email.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Email")); writer->WriteValue(Email); }
  
      if (Platform.notNull()) { writer->WriteIdentifierPrefix(TEXT("Platform")); writeLoginIdentityProviderEnumJSON(Platform, writer); }
  
      if (PlatformUserId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlatformUserId")); writer->WriteValue(PlatformUserId); }
  
      if (Username.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Username")); writer->WriteValue(Username); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkedPlatformAccountModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EmailValue = obj->TryGetField(TEXT("Email"));
      if (EmailValue.IsValid() && !EmailValue->IsNull())
      {
          FString TmpValue;
          if (EmailValue->TryGetString(TmpValue)) { Email = TmpValue; }
      }
  
      Platform = readLoginIdentityProviderFromValue(obj->TryGetField(TEXT("Platform")));
  
      const TSharedPtr<FJsonValue> PlatformUserIdValue = obj->TryGetField(TEXT("PlatformUserId"));
      if (PlatformUserIdValue.IsValid() && !PlatformUserIdValue->IsNull())
      {
          FString TmpValue;
          if (PlatformUserIdValue->TryGetString(TmpValue)) { PlatformUserId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UsernameValue = obj->TryGetField(TEXT("Username"));
      if (UsernameValue.IsValid() && !UsernameValue->IsNull())
      {
          FString TmpValue;
          if (UsernameValue->TryGetString(TmpValue)) { Username = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLocationModel::~FLocationModel()
  {
  
  }
  
  void PlayFab::ClientModels::FLocationModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (City.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("City")); writer->WriteValue(City); }
  
      if (pfContinentCode.notNull()) { writer->WriteIdentifierPrefix(TEXT("ContinentCode")); writeContinentCodeEnumJSON(pfContinentCode, writer); }
  
      if (pfCountryCode.notNull()) { writer->WriteIdentifierPrefix(TEXT("CountryCode")); writeCountryCodeEnumJSON(pfCountryCode, writer); }
  
      if (Latitude.notNull()) { writer->WriteIdentifierPrefix(TEXT("Latitude")); writer->WriteValue(Latitude); }
  
      if (Longitude.notNull()) { writer->WriteIdentifierPrefix(TEXT("Longitude")); writer->WriteValue(Longitude); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLocationModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CityValue = obj->TryGetField(TEXT("City"));
      if (CityValue.IsValid() && !CityValue->IsNull())
      {
          FString TmpValue;
          if (CityValue->TryGetString(TmpValue)) { City = TmpValue; }
      }
  
      pfContinentCode = readContinentCodeFromValue(obj->TryGetField(TEXT("ContinentCode")));
  
      pfCountryCode = readCountryCodeFromValue(obj->TryGetField(TEXT("CountryCode")));
  
      const TSharedPtr<FJsonValue> LatitudeValue = obj->TryGetField(TEXT("Latitude"));
      if (LatitudeValue.IsValid() && !LatitudeValue->IsNull())
      {
          double TmpValue;
          if (LatitudeValue->TryGetNumber(TmpValue)) { Latitude = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> LongitudeValue = obj->TryGetField(TEXT("Longitude"));
      if (LongitudeValue.IsValid() && !LongitudeValue->IsNull())
      {
          double TmpValue;
          if (LongitudeValue->TryGetNumber(TmpValue)) { Longitude = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeSubscriptionProviderStatusEnumJSON(SubscriptionProviderStatus enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case SubscriptionProviderStatusNoError: writer->WriteValue(TEXT("NoError")); break;
      case SubscriptionProviderStatusCancelled: writer->WriteValue(TEXT("Cancelled")); break;
      case SubscriptionProviderStatusUnknownError: writer->WriteValue(TEXT("UnknownError")); break;
      case SubscriptionProviderStatusBillingError: writer->WriteValue(TEXT("BillingError")); break;
      case SubscriptionProviderStatusProductUnavailable: writer->WriteValue(TEXT("ProductUnavailable")); break;
      case SubscriptionProviderStatusCustomerDidNotAcceptPriceChange: writer->WriteValue(TEXT("CustomerDidNotAcceptPriceChange")); break;
      case SubscriptionProviderStatusFreeTrial: writer->WriteValue(TEXT("FreeTrial")); break;
      case SubscriptionProviderStatusPaymentPending: writer->WriteValue(TEXT("PaymentPending")); break;
      }
  }
  
  ClientModels::SubscriptionProviderStatus PlayFab::ClientModels::readSubscriptionProviderStatusFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readSubscriptionProviderStatusFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::SubscriptionProviderStatus PlayFab::ClientModels::readSubscriptionProviderStatusFromValue(const FString& value)
  {
      static TMap<FString, SubscriptionProviderStatus> _SubscriptionProviderStatusMap;
      if (_SubscriptionProviderStatusMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _SubscriptionProviderStatusMap.Add(TEXT("NoError"), SubscriptionProviderStatusNoError);
          _SubscriptionProviderStatusMap.Add(TEXT("Cancelled"), SubscriptionProviderStatusCancelled);
          _SubscriptionProviderStatusMap.Add(TEXT("UnknownError"), SubscriptionProviderStatusUnknownError);
          _SubscriptionProviderStatusMap.Add(TEXT("BillingError"), SubscriptionProviderStatusBillingError);
          _SubscriptionProviderStatusMap.Add(TEXT("ProductUnavailable"), SubscriptionProviderStatusProductUnavailable);
          _SubscriptionProviderStatusMap.Add(TEXT("CustomerDidNotAcceptPriceChange"), SubscriptionProviderStatusCustomerDidNotAcceptPriceChange);
          _SubscriptionProviderStatusMap.Add(TEXT("FreeTrial"), SubscriptionProviderStatusFreeTrial);
          _SubscriptionProviderStatusMap.Add(TEXT("PaymentPending"), SubscriptionProviderStatusPaymentPending);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _SubscriptionProviderStatusMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return SubscriptionProviderStatusNoError; // Basically critical fail
  }
  
  PlayFab::ClientModels::FSubscriptionModel::~FSubscriptionModel()
  {
  
  }
  
  void PlayFab::ClientModels::FSubscriptionModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Expiration")); writeDatetime(Expiration, writer);
  
      writer->WriteIdentifierPrefix(TEXT("InitialSubscriptionTime")); writeDatetime(InitialSubscriptionTime, writer);
  
      writer->WriteIdentifierPrefix(TEXT("IsActive")); writer->WriteValue(IsActive);
  
      if (Status.notNull()) { writer->WriteIdentifierPrefix(TEXT("Status")); writeSubscriptionProviderStatusEnumJSON(Status, writer); }
  
      if (SubscriptionId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SubscriptionId")); writer->WriteValue(SubscriptionId); }
  
      if (SubscriptionItemId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SubscriptionItemId")); writer->WriteValue(SubscriptionItemId); }
  
      if (SubscriptionProvider.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SubscriptionProvider")); writer->WriteValue(SubscriptionProvider); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FSubscriptionModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ExpirationValue = obj->TryGetField(TEXT("Expiration"));
      if (ExpirationValue.IsValid())
          Expiration = readDatetime(ExpirationValue);
  
  
      const TSharedPtr<FJsonValue> InitialSubscriptionTimeValue = obj->TryGetField(TEXT("InitialSubscriptionTime"));
      if (InitialSubscriptionTimeValue.IsValid())
          InitialSubscriptionTime = readDatetime(InitialSubscriptionTimeValue);
  
  
      const TSharedPtr<FJsonValue> IsActiveValue = obj->TryGetField(TEXT("IsActive"));
      if (IsActiveValue.IsValid() && !IsActiveValue->IsNull())
      {
          bool TmpValue;
          if (IsActiveValue->TryGetBool(TmpValue)) { IsActive = TmpValue; }
      }
  
      Status = readSubscriptionProviderStatusFromValue(obj->TryGetField(TEXT("Status")));
  
      const TSharedPtr<FJsonValue> SubscriptionIdValue = obj->TryGetField(TEXT("SubscriptionId"));
      if (SubscriptionIdValue.IsValid() && !SubscriptionIdValue->IsNull())
      {
          FString TmpValue;
          if (SubscriptionIdValue->TryGetString(TmpValue)) { SubscriptionId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SubscriptionItemIdValue = obj->TryGetField(TEXT("SubscriptionItemId"));
      if (SubscriptionItemIdValue.IsValid() && !SubscriptionItemIdValue->IsNull())
      {
          FString TmpValue;
          if (SubscriptionItemIdValue->TryGetString(TmpValue)) { SubscriptionItemId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SubscriptionProviderValue = obj->TryGetField(TEXT("SubscriptionProvider"));
      if (SubscriptionProviderValue.IsValid() && !SubscriptionProviderValue->IsNull())
      {
          FString TmpValue;
          if (SubscriptionProviderValue->TryGetString(TmpValue)) { SubscriptionProvider = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FMembershipModel::~FMembershipModel()
  {
  
  }
  
  void PlayFab::ClientModels::FMembershipModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("IsActive")); writer->WriteValue(IsActive);
  
      writer->WriteIdentifierPrefix(TEXT("MembershipExpiration")); writeDatetime(MembershipExpiration, writer);
  
      if (MembershipId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("MembershipId")); writer->WriteValue(MembershipId); }
  
      if (OverrideExpiration.notNull()) { writer->WriteIdentifierPrefix(TEXT("OverrideExpiration")); writeDatetime(OverrideExpiration, writer); }
  
      if (OverrideIsSet.notNull()) { writer->WriteIdentifierPrefix(TEXT("OverrideIsSet")); writer->WriteValue(OverrideIsSet); }
  
      if (Subscriptions.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Subscriptions"));
          for (const FSubscriptionModel& item : Subscriptions)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FMembershipModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> IsActiveValue = obj->TryGetField(TEXT("IsActive"));
      if (IsActiveValue.IsValid() && !IsActiveValue->IsNull())
      {
          bool TmpValue;
          if (IsActiveValue->TryGetBool(TmpValue)) { IsActive = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> MembershipExpirationValue = obj->TryGetField(TEXT("MembershipExpiration"));
      if (MembershipExpirationValue.IsValid())
          MembershipExpiration = readDatetime(MembershipExpirationValue);
  
  
      const TSharedPtr<FJsonValue> MembershipIdValue = obj->TryGetField(TEXT("MembershipId"));
      if (MembershipIdValue.IsValid() && !MembershipIdValue->IsNull())
      {
          FString TmpValue;
          if (MembershipIdValue->TryGetString(TmpValue)) { MembershipId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> OverrideExpirationValue = obj->TryGetField(TEXT("OverrideExpiration"));
      if (OverrideExpirationValue.IsValid())
          OverrideExpiration = readDatetime(OverrideExpirationValue);
  
  
      const TSharedPtr<FJsonValue> OverrideIsSetValue = obj->TryGetField(TEXT("OverrideIsSet"));
      if (OverrideIsSetValue.IsValid() && !OverrideIsSetValue->IsNull())
      {
          bool TmpValue;
          if (OverrideIsSetValue->TryGetBool(TmpValue)) { OverrideIsSet = TmpValue; }
      }
  
      const TArray<TSharedPtr<FJsonValue>>&SubscriptionsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Subscriptions"));
      for (int32 Idx = 0; Idx < SubscriptionsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = SubscriptionsArray[Idx];
          Subscriptions.Add(FSubscriptionModel(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writePushNotificationPlatformEnumJSON(PushNotificationPlatform enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case PushNotificationPlatformApplePushNotificationService: writer->WriteValue(TEXT("ApplePushNotificationService")); break;
      case PushNotificationPlatformGoogleCloudMessaging: writer->WriteValue(TEXT("GoogleCloudMessaging")); break;
      }
  }
  
  ClientModels::PushNotificationPlatform PlayFab::ClientModels::readPushNotificationPlatformFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readPushNotificationPlatformFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::PushNotificationPlatform PlayFab::ClientModels::readPushNotificationPlatformFromValue(const FString& value)
  {
      static TMap<FString, PushNotificationPlatform> _PushNotificationPlatformMap;
      if (_PushNotificationPlatformMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _PushNotificationPlatformMap.Add(TEXT("ApplePushNotificationService"), PushNotificationPlatformApplePushNotificationService);
          _PushNotificationPlatformMap.Add(TEXT("GoogleCloudMessaging"), PushNotificationPlatformGoogleCloudMessaging);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _PushNotificationPlatformMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return PushNotificationPlatformApplePushNotificationService; // Basically critical fail
  }
  
  PlayFab::ClientModels::FPushNotificationRegistrationModel::~FPushNotificationRegistrationModel()
  {
  
  }
  
  void PlayFab::ClientModels::FPushNotificationRegistrationModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (NotificationEndpointARN.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("NotificationEndpointARN")); writer->WriteValue(NotificationEndpointARN); }
  
      if (Platform.notNull()) { writer->WriteIdentifierPrefix(TEXT("Platform")); writePushNotificationPlatformEnumJSON(Platform, writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPushNotificationRegistrationModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> NotificationEndpointARNValue = obj->TryGetField(TEXT("NotificationEndpointARN"));
      if (NotificationEndpointARNValue.IsValid() && !NotificationEndpointARNValue->IsNull())
      {
          FString TmpValue;
          if (NotificationEndpointARNValue->TryGetString(TmpValue)) { NotificationEndpointARN = TmpValue; }
      }
  
      Platform = readPushNotificationPlatformFromValue(obj->TryGetField(TEXT("Platform")));
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FStatisticModel::~FStatisticModel()
  {
  
  }
  
  void PlayFab::ClientModels::FStatisticModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Name.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Name")); writer->WriteValue(Name); }
  
      writer->WriteIdentifierPrefix(TEXT("Value")); writer->WriteValue(Value);
  
      writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(Version);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FStatisticModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> NameValue = obj->TryGetField(TEXT("Name"));
      if (NameValue.IsValid() && !NameValue->IsNull())
      {
          FString TmpValue;
          if (NameValue->TryGetString(TmpValue)) { Name = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ValueValue = obj->TryGetField(TEXT("Value"));
      if (ValueValue.IsValid() && !ValueValue->IsNull())
      {
          int32 TmpValue;
          if (ValueValue->TryGetNumber(TmpValue)) { Value = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          int32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FTagModel::~FTagModel()
  {
  
  }
  
  void PlayFab::ClientModels::FTagModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (TagValue.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TagValue")); writer->WriteValue(TagValue); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FTagModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> TagValueValue = obj->TryGetField(TEXT("TagValue"));
      if (TagValueValue.IsValid() && !TagValueValue->IsNull())
      {
          FString TmpValue;
          if (TagValueValue->TryGetString(TmpValue)) { TagValue = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FValueToDateModel::~FValueToDateModel()
  {
  
  }
  
  void PlayFab::ClientModels::FValueToDateModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Currency.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Currency")); writer->WriteValue(Currency); }
  
      writer->WriteIdentifierPrefix(TEXT("TotalValue")); writer->WriteValue(static_cast<int64>(TotalValue));
  
      if (TotalValueAsDecimal.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TotalValueAsDecimal")); writer->WriteValue(TotalValueAsDecimal); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FValueToDateModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CurrencyValue = obj->TryGetField(TEXT("Currency"));
      if (CurrencyValue.IsValid() && !CurrencyValue->IsNull())
      {
          FString TmpValue;
          if (CurrencyValue->TryGetString(TmpValue)) { Currency = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TotalValueValue = obj->TryGetField(TEXT("TotalValue"));
      if (TotalValueValue.IsValid() && !TotalValueValue->IsNull())
      {
          uint32 TmpValue;
          if (TotalValueValue->TryGetNumber(TmpValue)) { TotalValue = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TotalValueAsDecimalValue = obj->TryGetField(TEXT("TotalValueAsDecimal"));
      if (TotalValueAsDecimalValue.IsValid() && !TotalValueAsDecimalValue->IsNull())
      {
          FString TmpValue;
          if (TotalValueAsDecimalValue->TryGetString(TmpValue)) { TotalValueAsDecimal = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FPlayerProfileModel::~FPlayerProfileModel()
  {
  
  }
  
  void PlayFab::ClientModels::FPlayerProfileModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AdCampaignAttributions.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("AdCampaignAttributions"));
          for (const FAdCampaignAttributionModel& item : AdCampaignAttributions)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (AvatarUrl.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AvatarUrl")); writer->WriteValue(AvatarUrl); }
  
      if (BannedUntil.notNull()) { writer->WriteIdentifierPrefix(TEXT("BannedUntil")); writeDatetime(BannedUntil, writer); }
  
      if (ContactEmailAddresses.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("ContactEmailAddresses"));
          for (const FContactEmailInfoModel& item : ContactEmailAddresses)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (Created.notNull()) { writer->WriteIdentifierPrefix(TEXT("Created")); writeDatetime(Created, writer); }
  
      if (DisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DisplayName")); writer->WriteValue(DisplayName); }
  
      if (LastLogin.notNull()) { writer->WriteIdentifierPrefix(TEXT("LastLogin")); writeDatetime(LastLogin, writer); }
  
      if (LinkedAccounts.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("LinkedAccounts"));
          for (const FLinkedPlatformAccountModel& item : LinkedAccounts)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (Locations.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Locations"));
          for (const FLocationModel& item : Locations)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (Memberships.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Memberships"));
          for (const FMembershipModel& item : Memberships)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (Origination.notNull()) { writer->WriteIdentifierPrefix(TEXT("Origination")); writeLoginIdentityProviderEnumJSON(Origination, writer); }
  
      if (PlayerId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerId")); writer->WriteValue(PlayerId); }
  
      if (PublisherId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PublisherId")); writer->WriteValue(PublisherId); }
  
      if (PushNotificationRegistrations.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("PushNotificationRegistrations"));
          for (const FPushNotificationRegistrationModel& item : PushNotificationRegistrations)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (Statistics.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Statistics"));
          for (const FStatisticModel& item : Statistics)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (Tags.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Tags"));
          for (const FTagModel& item : Tags)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (TitleId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId); }
  
      if (TotalValueToDateInUSD.notNull()) { writer->WriteIdentifierPrefix(TEXT("TotalValueToDateInUSD")); writer->WriteValue(static_cast<int64>(TotalValueToDateInUSD)); }
  
      if (ValuesToDate.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("ValuesToDate"));
          for (const FValueToDateModel& item : ValuesToDate)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPlayerProfileModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&AdCampaignAttributionsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("AdCampaignAttributions"));
      for (int32 Idx = 0; Idx < AdCampaignAttributionsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = AdCampaignAttributionsArray[Idx];
          AdCampaignAttributions.Add(FAdCampaignAttributionModel(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> AvatarUrlValue = obj->TryGetField(TEXT("AvatarUrl"));
      if (AvatarUrlValue.IsValid() && !AvatarUrlValue->IsNull())
      {
          FString TmpValue;
          if (AvatarUrlValue->TryGetString(TmpValue)) { AvatarUrl = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> BannedUntilValue = obj->TryGetField(TEXT("BannedUntil"));
      if (BannedUntilValue.IsValid())
          BannedUntil = readDatetime(BannedUntilValue);
  
  
      const TArray<TSharedPtr<FJsonValue>>&ContactEmailAddressesArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("ContactEmailAddresses"));
      for (int32 Idx = 0; Idx < ContactEmailAddressesArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = ContactEmailAddressesArray[Idx];
          ContactEmailAddresses.Add(FContactEmailInfoModel(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> CreatedValue = obj->TryGetField(TEXT("Created"));
      if (CreatedValue.IsValid())
          Created = readDatetime(CreatedValue);
  
  
      const TSharedPtr<FJsonValue> DisplayNameValue = obj->TryGetField(TEXT("DisplayName"));
      if (DisplayNameValue.IsValid() && !DisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (DisplayNameValue->TryGetString(TmpValue)) { DisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> LastLoginValue = obj->TryGetField(TEXT("LastLogin"));
      if (LastLoginValue.IsValid())
          LastLogin = readDatetime(LastLoginValue);
  
  
      const TArray<TSharedPtr<FJsonValue>>&LinkedAccountsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("LinkedAccounts"));
      for (int32 Idx = 0; Idx < LinkedAccountsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = LinkedAccountsArray[Idx];
          LinkedAccounts.Add(FLinkedPlatformAccountModel(CurrentItem->AsObject()));
      }
  
  
      const TArray<TSharedPtr<FJsonValue>>&LocationsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Locations"));
      for (int32 Idx = 0; Idx < LocationsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = LocationsArray[Idx];
          Locations.Add(FLocationModel(CurrentItem->AsObject()));
      }
  
  
      const TArray<TSharedPtr<FJsonValue>>&MembershipsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Memberships"));
      for (int32 Idx = 0; Idx < MembershipsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = MembershipsArray[Idx];
          Memberships.Add(FMembershipModel(CurrentItem->AsObject()));
      }
  
  
      Origination = readLoginIdentityProviderFromValue(obj->TryGetField(TEXT("Origination")));
  
      const TSharedPtr<FJsonValue> PlayerIdValue = obj->TryGetField(TEXT("PlayerId"));
      if (PlayerIdValue.IsValid() && !PlayerIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayerIdValue->TryGetString(TmpValue)) { PlayerId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PublisherIdValue = obj->TryGetField(TEXT("PublisherId"));
      if (PublisherIdValue.IsValid() && !PublisherIdValue->IsNull())
      {
          FString TmpValue;
          if (PublisherIdValue->TryGetString(TmpValue)) { PublisherId = TmpValue; }
      }
  
      const TArray<TSharedPtr<FJsonValue>>&PushNotificationRegistrationsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("PushNotificationRegistrations"));
      for (int32 Idx = 0; Idx < PushNotificationRegistrationsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = PushNotificationRegistrationsArray[Idx];
          PushNotificationRegistrations.Add(FPushNotificationRegistrationModel(CurrentItem->AsObject()));
      }
  
  
      const TArray<TSharedPtr<FJsonValue>>&StatisticsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Statistics"));
      for (int32 Idx = 0; Idx < StatisticsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = StatisticsArray[Idx];
          Statistics.Add(FStatisticModel(CurrentItem->AsObject()));
      }
  
  
      const TArray<TSharedPtr<FJsonValue>>&TagsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Tags"));
      for (int32 Idx = 0; Idx < TagsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = TagsArray[Idx];
          Tags.Add(FTagModel(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TotalValueToDateInUSDValue = obj->TryGetField(TEXT("TotalValueToDateInUSD"));
      if (TotalValueToDateInUSDValue.IsValid() && !TotalValueToDateInUSDValue->IsNull())
      {
          uint32 TmpValue;
          if (TotalValueToDateInUSDValue->TryGetNumber(TmpValue)) { TotalValueToDateInUSD = TmpValue; }
      }
  
      const TArray<TSharedPtr<FJsonValue>>&ValuesToDateArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("ValuesToDate"));
      for (int32 Idx = 0; Idx < ValuesToDateArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = ValuesToDateArray[Idx];
          ValuesToDate.Add(FValueToDateModel(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserPsnInfo::~FUserPsnInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserPsnInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (PsnAccountId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PsnAccountId")); writer->WriteValue(PsnAccountId); }
  
      if (PsnOnlineId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PsnOnlineId")); writer->WriteValue(PsnOnlineId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserPsnInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PsnAccountIdValue = obj->TryGetField(TEXT("PsnAccountId"));
      if (PsnAccountIdValue.IsValid() && !PsnAccountIdValue->IsNull())
      {
          FString TmpValue;
          if (PsnAccountIdValue->TryGetString(TmpValue)) { PsnAccountId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PsnOnlineIdValue = obj->TryGetField(TEXT("PsnOnlineId"));
      if (PsnOnlineIdValue.IsValid() && !PsnOnlineIdValue->IsNull())
      {
          FString TmpValue;
          if (PsnOnlineIdValue->TryGetString(TmpValue)) { PsnOnlineId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeTitleActivationStatusEnumJSON(TitleActivationStatus enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case TitleActivationStatusNone: writer->WriteValue(TEXT("None")); break;
      case TitleActivationStatusActivatedTitleKey: writer->WriteValue(TEXT("ActivatedTitleKey")); break;
      case TitleActivationStatusPendingSteam: writer->WriteValue(TEXT("PendingSteam")); break;
      case TitleActivationStatusActivatedSteam: writer->WriteValue(TEXT("ActivatedSteam")); break;
      case TitleActivationStatusRevokedSteam: writer->WriteValue(TEXT("RevokedSteam")); break;
      }
  }
  
  ClientModels::TitleActivationStatus PlayFab::ClientModels::readTitleActivationStatusFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readTitleActivationStatusFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::TitleActivationStatus PlayFab::ClientModels::readTitleActivationStatusFromValue(const FString& value)
  {
      static TMap<FString, TitleActivationStatus> _TitleActivationStatusMap;
      if (_TitleActivationStatusMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _TitleActivationStatusMap.Add(TEXT("None"), TitleActivationStatusNone);
          _TitleActivationStatusMap.Add(TEXT("ActivatedTitleKey"), TitleActivationStatusActivatedTitleKey);
          _TitleActivationStatusMap.Add(TEXT("PendingSteam"), TitleActivationStatusPendingSteam);
          _TitleActivationStatusMap.Add(TEXT("ActivatedSteam"), TitleActivationStatusActivatedSteam);
          _TitleActivationStatusMap.Add(TEXT("RevokedSteam"), TitleActivationStatusRevokedSteam);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _TitleActivationStatusMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return TitleActivationStatusNone; // Basically critical fail
  }
  
  PlayFab::ClientModels::FUserSteamInfo::~FUserSteamInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserSteamInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (SteamActivationStatus.notNull()) { writer->WriteIdentifierPrefix(TEXT("SteamActivationStatus")); writeTitleActivationStatusEnumJSON(SteamActivationStatus, writer); }
  
      if (SteamCountry.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SteamCountry")); writer->WriteValue(SteamCountry); }
  
      if (SteamCurrency.notNull()) { writer->WriteIdentifierPrefix(TEXT("SteamCurrency")); writeCurrencyEnumJSON(SteamCurrency, writer); }
  
      if (SteamId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SteamId")); writer->WriteValue(SteamId); }
  
      if (SteamName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SteamName")); writer->WriteValue(SteamName); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserSteamInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      SteamActivationStatus = readTitleActivationStatusFromValue(obj->TryGetField(TEXT("SteamActivationStatus")));
  
      const TSharedPtr<FJsonValue> SteamCountryValue = obj->TryGetField(TEXT("SteamCountry"));
      if (SteamCountryValue.IsValid() && !SteamCountryValue->IsNull())
      {
          FString TmpValue;
          if (SteamCountryValue->TryGetString(TmpValue)) { SteamCountry = TmpValue; }
      }
  
      SteamCurrency = readCurrencyFromValue(obj->TryGetField(TEXT("SteamCurrency")));
  
      const TSharedPtr<FJsonValue> SteamIdValue = obj->TryGetField(TEXT("SteamId"));
      if (SteamIdValue.IsValid() && !SteamIdValue->IsNull())
      {
          FString TmpValue;
          if (SteamIdValue->TryGetString(TmpValue)) { SteamId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SteamNameValue = obj->TryGetField(TEXT("SteamName"));
      if (SteamNameValue.IsValid() && !SteamNameValue->IsNull())
      {
          FString TmpValue;
          if (SteamNameValue->TryGetString(TmpValue)) { SteamName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserXboxInfo::~FUserXboxInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserXboxInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (XboxUserId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("XboxUserId")); writer->WriteValue(XboxUserId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserXboxInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> XboxUserIdValue = obj->TryGetField(TEXT("XboxUserId"));
      if (XboxUserIdValue.IsValid() && !XboxUserIdValue->IsNull())
      {
          FString TmpValue;
          if (XboxUserIdValue->TryGetString(TmpValue)) { XboxUserId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FFriendInfo::~FFriendInfo()
  {
      //if (FacebookInfo != nullptr) delete FacebookInfo;
      //if (GameCenterInfo != nullptr) delete GameCenterInfo;
      //if (Profile != nullptr) delete Profile;
      //if (PSNInfo != nullptr) delete PSNInfo;
      //if (SteamInfo != nullptr) delete SteamInfo;
      //if (XboxInfo != nullptr) delete XboxInfo;
  
  }
  
  void PlayFab::ClientModels::FFriendInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (FacebookInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("FacebookInfo")); FacebookInfo->writeJSON(writer); }
  
      if (FriendPlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FriendPlayFabId")); writer->WriteValue(FriendPlayFabId); }
  
      if (GameCenterInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("GameCenterInfo")); GameCenterInfo->writeJSON(writer); }
  
      if (Profile.IsValid()) { writer->WriteIdentifierPrefix(TEXT("Profile")); Profile->writeJSON(writer); }
  
      if (PSNInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("PSNInfo")); PSNInfo->writeJSON(writer); }
  
      if (SteamInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("SteamInfo")); SteamInfo->writeJSON(writer); }
  
      if (Tags.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Tags"));
          for (const FString& item : Tags)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (TitleDisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TitleDisplayName")); writer->WriteValue(TitleDisplayName); }
  
      if (Username.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Username")); writer->WriteValue(Username); }
  
      if (XboxInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("XboxInfo")); XboxInfo->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FFriendInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> FacebookInfoValue = obj->TryGetField(TEXT("FacebookInfo"));
      if (FacebookInfoValue.IsValid() && !FacebookInfoValue->IsNull())
      {
          FacebookInfo = MakeShareable(new FUserFacebookInfo(FacebookInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> FriendPlayFabIdValue = obj->TryGetField(TEXT("FriendPlayFabId"));
      if (FriendPlayFabIdValue.IsValid() && !FriendPlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (FriendPlayFabIdValue->TryGetString(TmpValue)) { FriendPlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GameCenterInfoValue = obj->TryGetField(TEXT("GameCenterInfo"));
      if (GameCenterInfoValue.IsValid() && !GameCenterInfoValue->IsNull())
      {
          GameCenterInfo = MakeShareable(new FUserGameCenterInfo(GameCenterInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> ProfileValue = obj->TryGetField(TEXT("Profile"));
      if (ProfileValue.IsValid() && !ProfileValue->IsNull())
      {
          Profile = MakeShareable(new FPlayerProfileModel(ProfileValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PSNInfoValue = obj->TryGetField(TEXT("PSNInfo"));
      if (PSNInfoValue.IsValid() && !PSNInfoValue->IsNull())
      {
          PSNInfo = MakeShareable(new FUserPsnInfo(PSNInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> SteamInfoValue = obj->TryGetField(TEXT("SteamInfo"));
      if (SteamInfoValue.IsValid() && !SteamInfoValue->IsNull())
      {
          SteamInfo = MakeShareable(new FUserSteamInfo(SteamInfoValue->AsObject()));
      }
  
      obj->TryGetStringArrayField(TEXT("Tags"), Tags);
  
      const TSharedPtr<FJsonValue> TitleDisplayNameValue = obj->TryGetField(TEXT("TitleDisplayName"));
      if (TitleDisplayNameValue.IsValid() && !TitleDisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (TitleDisplayNameValue->TryGetString(TmpValue)) { TitleDisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UsernameValue = obj->TryGetField(TEXT("Username"));
      if (UsernameValue.IsValid() && !UsernameValue->IsNull())
      {
          FString TmpValue;
          if (UsernameValue->TryGetString(TmpValue)) { Username = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> XboxInfoValue = obj->TryGetField(TEXT("XboxInfo"));
      if (XboxInfoValue.IsValid() && !XboxInfoValue->IsNull())
      {
          XboxInfo = MakeShareable(new FUserXboxInfo(XboxInfoValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGameCenterPlayFabIdPair::~FGameCenterPlayFabIdPair()
  {
  
  }
  
  void PlayFab::ClientModels::FGameCenterPlayFabIdPair::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (GameCenterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GameCenterId")); writer->WriteValue(GameCenterId); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGameCenterPlayFabIdPair::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> GameCenterIdValue = obj->TryGetField(TEXT("GameCenterId"));
      if (GameCenterIdValue.IsValid() && !GameCenterIdValue->IsNull())
      {
          FString TmpValue;
          if (GameCenterIdValue->TryGetString(TmpValue)) { GameCenterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGameServerRegionsRequest::~FGameServerRegionsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGameServerRegionsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("BuildVersion")); writer->WriteValue(BuildVersion);
  
      if (TitleId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGameServerRegionsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> BuildVersionValue = obj->TryGetField(TEXT("BuildVersion"));
      if (BuildVersionValue.IsValid() && !BuildVersionValue->IsNull())
      {
          FString TmpValue;
          if (BuildVersionValue->TryGetString(TmpValue)) { BuildVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRegionInfo::~FRegionInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FRegionInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Available")); writer->WriteValue(Available);
  
      if (Name.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Name")); writer->WriteValue(Name); }
  
      if (PingUrl.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PingUrl")); writer->WriteValue(PingUrl); }
  
      if (pfRegion.notNull()) { writer->WriteIdentifierPrefix(TEXT("Region")); writeRegionEnumJSON(pfRegion, writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRegionInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AvailableValue = obj->TryGetField(TEXT("Available"));
      if (AvailableValue.IsValid() && !AvailableValue->IsNull())
      {
          bool TmpValue;
          if (AvailableValue->TryGetBool(TmpValue)) { Available = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> NameValue = obj->TryGetField(TEXT("Name"));
      if (NameValue.IsValid() && !NameValue->IsNull())
      {
          FString TmpValue;
          if (NameValue->TryGetString(TmpValue)) { Name = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PingUrlValue = obj->TryGetField(TEXT("PingUrl"));
      if (PingUrlValue.IsValid() && !PingUrlValue->IsNull())
      {
          FString TmpValue;
          if (PingUrlValue->TryGetString(TmpValue)) { PingUrl = TmpValue; }
      }
  
      pfRegion = readRegionFromValue(obj->TryGetField(TEXT("Region")));
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGameServerRegionsResult::~FGameServerRegionsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGameServerRegionsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Regions.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Regions"));
          for (const FRegionInfo& item : Regions)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGameServerRegionsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&RegionsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Regions"));
      for (int32 Idx = 0; Idx < RegionsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = RegionsArray[Idx];
          Regions.Add(FRegionInfo(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGenericPlayFabIdPair::~FGenericPlayFabIdPair()
  {
      //if (GenericId != nullptr) delete GenericId;
  
  }
  
  void PlayFab::ClientModels::FGenericPlayFabIdPair::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (GenericId.IsValid()) { writer->WriteIdentifierPrefix(TEXT("GenericId")); GenericId->writeJSON(writer); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGenericPlayFabIdPair::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> GenericIdValue = obj->TryGetField(TEXT("GenericId"));
      if (GenericIdValue.IsValid() && !GenericIdValue->IsNull())
      {
          GenericId = MakeShareable(new FGenericServiceId(GenericIdValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetAccountInfoRequest::~FGetAccountInfoRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetAccountInfoRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Email.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Email")); writer->WriteValue(Email); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (TitleDisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TitleDisplayName")); writer->WriteValue(TitleDisplayName); }
  
      if (Username.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Username")); writer->WriteValue(Username); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetAccountInfoRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EmailValue = obj->TryGetField(TEXT("Email"));
      if (EmailValue.IsValid() && !EmailValue->IsNull())
      {
          FString TmpValue;
          if (EmailValue->TryGetString(TmpValue)) { Email = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleDisplayNameValue = obj->TryGetField(TEXT("TitleDisplayName"));
      if (TitleDisplayNameValue.IsValid() && !TitleDisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (TitleDisplayNameValue->TryGetString(TmpValue)) { TitleDisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UsernameValue = obj->TryGetField(TEXT("Username"));
      if (UsernameValue.IsValid() && !UsernameValue->IsNull())
      {
          FString TmpValue;
          if (UsernameValue->TryGetString(TmpValue)) { Username = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserAndroidDeviceInfo::~FUserAndroidDeviceInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserAndroidDeviceInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AndroidDeviceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AndroidDeviceId")); writer->WriteValue(AndroidDeviceId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserAndroidDeviceInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AndroidDeviceIdValue = obj->TryGetField(TEXT("AndroidDeviceId"));
      if (AndroidDeviceIdValue.IsValid() && !AndroidDeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (AndroidDeviceIdValue->TryGetString(TmpValue)) { AndroidDeviceId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserCustomIdInfo::~FUserCustomIdInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserCustomIdInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CustomId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CustomId")); writer->WriteValue(CustomId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserCustomIdInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CustomIdValue = obj->TryGetField(TEXT("CustomId"));
      if (CustomIdValue.IsValid() && !CustomIdValue->IsNull())
      {
          FString TmpValue;
          if (CustomIdValue->TryGetString(TmpValue)) { CustomId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserFacebookInstantGamesIdInfo::~FUserFacebookInstantGamesIdInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserFacebookInstantGamesIdInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (FacebookInstantGamesId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FacebookInstantGamesId")); writer->WriteValue(FacebookInstantGamesId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserFacebookInstantGamesIdInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> FacebookInstantGamesIdValue = obj->TryGetField(TEXT("FacebookInstantGamesId"));
      if (FacebookInstantGamesIdValue.IsValid() && !FacebookInstantGamesIdValue->IsNull())
      {
          FString TmpValue;
          if (FacebookInstantGamesIdValue->TryGetString(TmpValue)) { FacebookInstantGamesId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserGoogleInfo::~FUserGoogleInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserGoogleInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (GoogleEmail.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GoogleEmail")); writer->WriteValue(GoogleEmail); }
  
      if (GoogleGender.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GoogleGender")); writer->WriteValue(GoogleGender); }
  
      if (GoogleId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GoogleId")); writer->WriteValue(GoogleId); }
  
      if (GoogleLocale.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GoogleLocale")); writer->WriteValue(GoogleLocale); }
  
      if (GoogleName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GoogleName")); writer->WriteValue(GoogleName); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserGoogleInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> GoogleEmailValue = obj->TryGetField(TEXT("GoogleEmail"));
      if (GoogleEmailValue.IsValid() && !GoogleEmailValue->IsNull())
      {
          FString TmpValue;
          if (GoogleEmailValue->TryGetString(TmpValue)) { GoogleEmail = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GoogleGenderValue = obj->TryGetField(TEXT("GoogleGender"));
      if (GoogleGenderValue.IsValid() && !GoogleGenderValue->IsNull())
      {
          FString TmpValue;
          if (GoogleGenderValue->TryGetString(TmpValue)) { GoogleGender = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GoogleIdValue = obj->TryGetField(TEXT("GoogleId"));
      if (GoogleIdValue.IsValid() && !GoogleIdValue->IsNull())
      {
          FString TmpValue;
          if (GoogleIdValue->TryGetString(TmpValue)) { GoogleId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GoogleLocaleValue = obj->TryGetField(TEXT("GoogleLocale"));
      if (GoogleLocaleValue.IsValid() && !GoogleLocaleValue->IsNull())
      {
          FString TmpValue;
          if (GoogleLocaleValue->TryGetString(TmpValue)) { GoogleLocale = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GoogleNameValue = obj->TryGetField(TEXT("GoogleName"));
      if (GoogleNameValue.IsValid() && !GoogleNameValue->IsNull())
      {
          FString TmpValue;
          if (GoogleNameValue->TryGetString(TmpValue)) { GoogleName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserIosDeviceInfo::~FUserIosDeviceInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserIosDeviceInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (IosDeviceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("IosDeviceId")); writer->WriteValue(IosDeviceId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserIosDeviceInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> IosDeviceIdValue = obj->TryGetField(TEXT("IosDeviceId"));
      if (IosDeviceIdValue.IsValid() && !IosDeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (IosDeviceIdValue->TryGetString(TmpValue)) { IosDeviceId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserKongregateInfo::~FUserKongregateInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserKongregateInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (KongregateId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("KongregateId")); writer->WriteValue(KongregateId); }
  
      if (KongregateName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("KongregateName")); writer->WriteValue(KongregateName); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserKongregateInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> KongregateIdValue = obj->TryGetField(TEXT("KongregateId"));
      if (KongregateIdValue.IsValid() && !KongregateIdValue->IsNull())
      {
          FString TmpValue;
          if (KongregateIdValue->TryGetString(TmpValue)) { KongregateId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> KongregateNameValue = obj->TryGetField(TEXT("KongregateName"));
      if (KongregateNameValue.IsValid() && !KongregateNameValue->IsNull())
      {
          FString TmpValue;
          if (KongregateNameValue->TryGetString(TmpValue)) { KongregateName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserNintendoSwitchDeviceIdInfo::~FUserNintendoSwitchDeviceIdInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserNintendoSwitchDeviceIdInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (NintendoSwitchDeviceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("NintendoSwitchDeviceId")); writer->WriteValue(NintendoSwitchDeviceId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserNintendoSwitchDeviceIdInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> NintendoSwitchDeviceIdValue = obj->TryGetField(TEXT("NintendoSwitchDeviceId"));
      if (NintendoSwitchDeviceIdValue.IsValid() && !NintendoSwitchDeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (NintendoSwitchDeviceIdValue->TryGetString(TmpValue)) { NintendoSwitchDeviceId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserOpenIdInfo::~FUserOpenIdInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserOpenIdInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ConnectionId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ConnectionId")); writer->WriteValue(ConnectionId); }
  
      if (Issuer.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Issuer")); writer->WriteValue(Issuer); }
  
      if (Subject.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Subject")); writer->WriteValue(Subject); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserOpenIdInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ConnectionIdValue = obj->TryGetField(TEXT("ConnectionId"));
      if (ConnectionIdValue.IsValid() && !ConnectionIdValue->IsNull())
      {
          FString TmpValue;
          if (ConnectionIdValue->TryGetString(TmpValue)) { ConnectionId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IssuerValue = obj->TryGetField(TEXT("Issuer"));
      if (IssuerValue.IsValid() && !IssuerValue->IsNull())
      {
          FString TmpValue;
          if (IssuerValue->TryGetString(TmpValue)) { Issuer = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SubjectValue = obj->TryGetField(TEXT("Subject"));
      if (SubjectValue.IsValid() && !SubjectValue->IsNull())
      {
          FString TmpValue;
          if (SubjectValue->TryGetString(TmpValue)) { Subject = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserPrivateAccountInfo::~FUserPrivateAccountInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserPrivateAccountInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Email.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Email")); writer->WriteValue(Email); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserPrivateAccountInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EmailValue = obj->TryGetField(TEXT("Email"));
      if (EmailValue.IsValid() && !EmailValue->IsNull())
      {
          FString TmpValue;
          if (EmailValue->TryGetString(TmpValue)) { Email = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeUserOriginationEnumJSON(UserOrigination enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case UserOriginationOrganic: writer->WriteValue(TEXT("Organic")); break;
      case UserOriginationSteam: writer->WriteValue(TEXT("Steam")); break;
      case UserOriginationGoogle: writer->WriteValue(TEXT("Google")); break;
      case UserOriginationAmazon: writer->WriteValue(TEXT("Amazon")); break;
      case UserOriginationFacebook: writer->WriteValue(TEXT("Facebook")); break;
      case UserOriginationKongregate: writer->WriteValue(TEXT("Kongregate")); break;
      case UserOriginationGamersFirst: writer->WriteValue(TEXT("GamersFirst")); break;
      case UserOriginationUnknown: writer->WriteValue(TEXT("Unknown")); break;
      case UserOriginationIOS: writer->WriteValue(TEXT("IOS")); break;
      case UserOriginationLoadTest: writer->WriteValue(TEXT("LoadTest")); break;
      case UserOriginationAndroid: writer->WriteValue(TEXT("Android")); break;
      case UserOriginationPSN: writer->WriteValue(TEXT("PSN")); break;
      case UserOriginationGameCenter: writer->WriteValue(TEXT("GameCenter")); break;
      case UserOriginationCustomId: writer->WriteValue(TEXT("CustomId")); break;
      case UserOriginationXboxLive: writer->WriteValue(TEXT("XboxLive")); break;
      case UserOriginationParse: writer->WriteValue(TEXT("Parse")); break;
      case UserOriginationTwitch: writer->WriteValue(TEXT("Twitch")); break;
      case UserOriginationWindowsHello: writer->WriteValue(TEXT("WindowsHello")); break;
      case UserOriginationServerCustomId: writer->WriteValue(TEXT("ServerCustomId")); break;
      case UserOriginationNintendoSwitchDeviceId: writer->WriteValue(TEXT("NintendoSwitchDeviceId")); break;
      case UserOriginationFacebookInstantGamesId: writer->WriteValue(TEXT("FacebookInstantGamesId")); break;
      case UserOriginationOpenIdConnect: writer->WriteValue(TEXT("OpenIdConnect")); break;
      }
  }
  
  ClientModels::UserOrigination PlayFab::ClientModels::readUserOriginationFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readUserOriginationFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::UserOrigination PlayFab::ClientModels::readUserOriginationFromValue(const FString& value)
  {
      static TMap<FString, UserOrigination> _UserOriginationMap;
      if (_UserOriginationMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _UserOriginationMap.Add(TEXT("Organic"), UserOriginationOrganic);
          _UserOriginationMap.Add(TEXT("Steam"), UserOriginationSteam);
          _UserOriginationMap.Add(TEXT("Google"), UserOriginationGoogle);
          _UserOriginationMap.Add(TEXT("Amazon"), UserOriginationAmazon);
          _UserOriginationMap.Add(TEXT("Facebook"), UserOriginationFacebook);
          _UserOriginationMap.Add(TEXT("Kongregate"), UserOriginationKongregate);
          _UserOriginationMap.Add(TEXT("GamersFirst"), UserOriginationGamersFirst);
          _UserOriginationMap.Add(TEXT("Unknown"), UserOriginationUnknown);
          _UserOriginationMap.Add(TEXT("IOS"), UserOriginationIOS);
          _UserOriginationMap.Add(TEXT("LoadTest"), UserOriginationLoadTest);
          _UserOriginationMap.Add(TEXT("Android"), UserOriginationAndroid);
          _UserOriginationMap.Add(TEXT("PSN"), UserOriginationPSN);
          _UserOriginationMap.Add(TEXT("GameCenter"), UserOriginationGameCenter);
          _UserOriginationMap.Add(TEXT("CustomId"), UserOriginationCustomId);
          _UserOriginationMap.Add(TEXT("XboxLive"), UserOriginationXboxLive);
          _UserOriginationMap.Add(TEXT("Parse"), UserOriginationParse);
          _UserOriginationMap.Add(TEXT("Twitch"), UserOriginationTwitch);
          _UserOriginationMap.Add(TEXT("WindowsHello"), UserOriginationWindowsHello);
          _UserOriginationMap.Add(TEXT("ServerCustomId"), UserOriginationServerCustomId);
          _UserOriginationMap.Add(TEXT("NintendoSwitchDeviceId"), UserOriginationNintendoSwitchDeviceId);
          _UserOriginationMap.Add(TEXT("FacebookInstantGamesId"), UserOriginationFacebookInstantGamesId);
          _UserOriginationMap.Add(TEXT("OpenIdConnect"), UserOriginationOpenIdConnect);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _UserOriginationMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return UserOriginationOrganic; // Basically critical fail
  }
  
  PlayFab::ClientModels::FUserTitleInfo::~FUserTitleInfo()
  {
      //if (TitlePlayerAccount != nullptr) delete TitlePlayerAccount;
  
  }
  
  void PlayFab::ClientModels::FUserTitleInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AvatarUrl.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AvatarUrl")); writer->WriteValue(AvatarUrl); }
  
      writer->WriteIdentifierPrefix(TEXT("Created")); writeDatetime(Created, writer);
  
      if (DisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DisplayName")); writer->WriteValue(DisplayName); }
  
      if (FirstLogin.notNull()) { writer->WriteIdentifierPrefix(TEXT("FirstLogin")); writeDatetime(FirstLogin, writer); }
  
      if (isBanned.notNull()) { writer->WriteIdentifierPrefix(TEXT("isBanned")); writer->WriteValue(isBanned); }
  
      if (LastLogin.notNull()) { writer->WriteIdentifierPrefix(TEXT("LastLogin")); writeDatetime(LastLogin, writer); }
  
      if (Origination.notNull()) { writer->WriteIdentifierPrefix(TEXT("Origination")); writeUserOriginationEnumJSON(Origination, writer); }
  
      if (TitlePlayerAccount.IsValid()) { writer->WriteIdentifierPrefix(TEXT("TitlePlayerAccount")); TitlePlayerAccount->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserTitleInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AvatarUrlValue = obj->TryGetField(TEXT("AvatarUrl"));
      if (AvatarUrlValue.IsValid() && !AvatarUrlValue->IsNull())
      {
          FString TmpValue;
          if (AvatarUrlValue->TryGetString(TmpValue)) { AvatarUrl = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CreatedValue = obj->TryGetField(TEXT("Created"));
      if (CreatedValue.IsValid())
          Created = readDatetime(CreatedValue);
  
  
      const TSharedPtr<FJsonValue> DisplayNameValue = obj->TryGetField(TEXT("DisplayName"));
      if (DisplayNameValue.IsValid() && !DisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (DisplayNameValue->TryGetString(TmpValue)) { DisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> FirstLoginValue = obj->TryGetField(TEXT("FirstLogin"));
      if (FirstLoginValue.IsValid())
          FirstLogin = readDatetime(FirstLoginValue);
  
  
      const TSharedPtr<FJsonValue> isBannedValue = obj->TryGetField(TEXT("isBanned"));
      if (isBannedValue.IsValid() && !isBannedValue->IsNull())
      {
          bool TmpValue;
          if (isBannedValue->TryGetBool(TmpValue)) { isBanned = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> LastLoginValue = obj->TryGetField(TEXT("LastLogin"));
      if (LastLoginValue.IsValid())
          LastLogin = readDatetime(LastLoginValue);
  
  
      Origination = readUserOriginationFromValue(obj->TryGetField(TEXT("Origination")));
  
      const TSharedPtr<FJsonValue> TitlePlayerAccountValue = obj->TryGetField(TEXT("TitlePlayerAccount"));
      if (TitlePlayerAccountValue.IsValid() && !TitlePlayerAccountValue->IsNull())
      {
          TitlePlayerAccount = MakeShareable(new FEntityKey(TitlePlayerAccountValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserTwitchInfo::~FUserTwitchInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserTwitchInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (TwitchId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TwitchId")); writer->WriteValue(TwitchId); }
  
      if (TwitchUserName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TwitchUserName")); writer->WriteValue(TwitchUserName); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserTwitchInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> TwitchIdValue = obj->TryGetField(TEXT("TwitchId"));
      if (TwitchIdValue.IsValid() && !TwitchIdValue->IsNull())
      {
          FString TmpValue;
          if (TwitchIdValue->TryGetString(TmpValue)) { TwitchId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TwitchUserNameValue = obj->TryGetField(TEXT("TwitchUserName"));
      if (TwitchUserNameValue.IsValid() && !TwitchUserNameValue->IsNull())
      {
          FString TmpValue;
          if (TwitchUserNameValue->TryGetString(TmpValue)) { TwitchUserName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserWindowsHelloInfo::~FUserWindowsHelloInfo()
  {
  
  }
  
  void PlayFab::ClientModels::FUserWindowsHelloInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (WindowsHelloDeviceName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("WindowsHelloDeviceName")); writer->WriteValue(WindowsHelloDeviceName); }
  
      if (WindowsHelloPublicKeyHash.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("WindowsHelloPublicKeyHash")); writer->WriteValue(WindowsHelloPublicKeyHash); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserWindowsHelloInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> WindowsHelloDeviceNameValue = obj->TryGetField(TEXT("WindowsHelloDeviceName"));
      if (WindowsHelloDeviceNameValue.IsValid() && !WindowsHelloDeviceNameValue->IsNull())
      {
          FString TmpValue;
          if (WindowsHelloDeviceNameValue->TryGetString(TmpValue)) { WindowsHelloDeviceName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> WindowsHelloPublicKeyHashValue = obj->TryGetField(TEXT("WindowsHelloPublicKeyHash"));
      if (WindowsHelloPublicKeyHashValue.IsValid() && !WindowsHelloPublicKeyHashValue->IsNull())
      {
          FString TmpValue;
          if (WindowsHelloPublicKeyHashValue->TryGetString(TmpValue)) { WindowsHelloPublicKeyHash = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserAccountInfo::~FUserAccountInfo()
  {
      //if (AndroidDeviceInfo != nullptr) delete AndroidDeviceInfo;
      //if (CustomIdInfo != nullptr) delete CustomIdInfo;
      //if (FacebookInfo != nullptr) delete FacebookInfo;
      //if (FacebookInstantGamesIdInfo != nullptr) delete FacebookInstantGamesIdInfo;
      //if (GameCenterInfo != nullptr) delete GameCenterInfo;
      //if (GoogleInfo != nullptr) delete GoogleInfo;
      //if (IosDeviceInfo != nullptr) delete IosDeviceInfo;
      //if (KongregateInfo != nullptr) delete KongregateInfo;
      //if (NintendoSwitchDeviceIdInfo != nullptr) delete NintendoSwitchDeviceIdInfo;
      //if (PrivateInfo != nullptr) delete PrivateInfo;
      //if (PsnInfo != nullptr) delete PsnInfo;
      //if (SteamInfo != nullptr) delete SteamInfo;
      //if (TitleInfo != nullptr) delete TitleInfo;
      //if (TwitchInfo != nullptr) delete TwitchInfo;
      //if (WindowsHelloInfo != nullptr) delete WindowsHelloInfo;
      //if (XboxInfo != nullptr) delete XboxInfo;
  
  }
  
  void PlayFab::ClientModels::FUserAccountInfo::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AndroidDeviceInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("AndroidDeviceInfo")); AndroidDeviceInfo->writeJSON(writer); }
  
      writer->WriteIdentifierPrefix(TEXT("Created")); writeDatetime(Created, writer);
  
      if (CustomIdInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("CustomIdInfo")); CustomIdInfo->writeJSON(writer); }
  
      if (FacebookInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("FacebookInfo")); FacebookInfo->writeJSON(writer); }
  
      if (FacebookInstantGamesIdInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("FacebookInstantGamesIdInfo")); FacebookInstantGamesIdInfo->writeJSON(writer); }
  
      if (GameCenterInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("GameCenterInfo")); GameCenterInfo->writeJSON(writer); }
  
      if (GoogleInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("GoogleInfo")); GoogleInfo->writeJSON(writer); }
  
      if (IosDeviceInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("IosDeviceInfo")); IosDeviceInfo->writeJSON(writer); }
  
      if (KongregateInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("KongregateInfo")); KongregateInfo->writeJSON(writer); }
  
      if (NintendoSwitchDeviceIdInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("NintendoSwitchDeviceIdInfo")); NintendoSwitchDeviceIdInfo->writeJSON(writer); }
  
      if (OpenIdInfo.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("OpenIdInfo"));
          for (const FUserOpenIdInfo& item : OpenIdInfo)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (PrivateInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("PrivateInfo")); PrivateInfo->writeJSON(writer); }
  
      if (PsnInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("PsnInfo")); PsnInfo->writeJSON(writer); }
  
      if (SteamInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("SteamInfo")); SteamInfo->writeJSON(writer); }
  
      if (TitleInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("TitleInfo")); TitleInfo->writeJSON(writer); }
  
      if (TwitchInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("TwitchInfo")); TwitchInfo->writeJSON(writer); }
  
      if (Username.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Username")); writer->WriteValue(Username); }
  
      if (WindowsHelloInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("WindowsHelloInfo")); WindowsHelloInfo->writeJSON(writer); }
  
      if (XboxInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("XboxInfo")); XboxInfo->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserAccountInfo::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AndroidDeviceInfoValue = obj->TryGetField(TEXT("AndroidDeviceInfo"));
      if (AndroidDeviceInfoValue.IsValid() && !AndroidDeviceInfoValue->IsNull())
      {
          AndroidDeviceInfo = MakeShareable(new FUserAndroidDeviceInfo(AndroidDeviceInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> CreatedValue = obj->TryGetField(TEXT("Created"));
      if (CreatedValue.IsValid())
          Created = readDatetime(CreatedValue);
  
  
      const TSharedPtr<FJsonValue> CustomIdInfoValue = obj->TryGetField(TEXT("CustomIdInfo"));
      if (CustomIdInfoValue.IsValid() && !CustomIdInfoValue->IsNull())
      {
          CustomIdInfo = MakeShareable(new FUserCustomIdInfo(CustomIdInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> FacebookInfoValue = obj->TryGetField(TEXT("FacebookInfo"));
      if (FacebookInfoValue.IsValid() && !FacebookInfoValue->IsNull())
      {
          FacebookInfo = MakeShareable(new FUserFacebookInfo(FacebookInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> FacebookInstantGamesIdInfoValue = obj->TryGetField(TEXT("FacebookInstantGamesIdInfo"));
      if (FacebookInstantGamesIdInfoValue.IsValid() && !FacebookInstantGamesIdInfoValue->IsNull())
      {
          FacebookInstantGamesIdInfo = MakeShareable(new FUserFacebookInstantGamesIdInfo(FacebookInstantGamesIdInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> GameCenterInfoValue = obj->TryGetField(TEXT("GameCenterInfo"));
      if (GameCenterInfoValue.IsValid() && !GameCenterInfoValue->IsNull())
      {
          GameCenterInfo = MakeShareable(new FUserGameCenterInfo(GameCenterInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> GoogleInfoValue = obj->TryGetField(TEXT("GoogleInfo"));
      if (GoogleInfoValue.IsValid() && !GoogleInfoValue->IsNull())
      {
          GoogleInfo = MakeShareable(new FUserGoogleInfo(GoogleInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> IosDeviceInfoValue = obj->TryGetField(TEXT("IosDeviceInfo"));
      if (IosDeviceInfoValue.IsValid() && !IosDeviceInfoValue->IsNull())
      {
          IosDeviceInfo = MakeShareable(new FUserIosDeviceInfo(IosDeviceInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> KongregateInfoValue = obj->TryGetField(TEXT("KongregateInfo"));
      if (KongregateInfoValue.IsValid() && !KongregateInfoValue->IsNull())
      {
          KongregateInfo = MakeShareable(new FUserKongregateInfo(KongregateInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> NintendoSwitchDeviceIdInfoValue = obj->TryGetField(TEXT("NintendoSwitchDeviceIdInfo"));
      if (NintendoSwitchDeviceIdInfoValue.IsValid() && !NintendoSwitchDeviceIdInfoValue->IsNull())
      {
          NintendoSwitchDeviceIdInfo = MakeShareable(new FUserNintendoSwitchDeviceIdInfo(NintendoSwitchDeviceIdInfoValue->AsObject()));
      }
  
      const TArray<TSharedPtr<FJsonValue>>&OpenIdInfoArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("OpenIdInfo"));
      for (int32 Idx = 0; Idx < OpenIdInfoArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = OpenIdInfoArray[Idx];
          OpenIdInfo.Add(FUserOpenIdInfo(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PrivateInfoValue = obj->TryGetField(TEXT("PrivateInfo"));
      if (PrivateInfoValue.IsValid() && !PrivateInfoValue->IsNull())
      {
          PrivateInfo = MakeShareable(new FUserPrivateAccountInfo(PrivateInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PsnInfoValue = obj->TryGetField(TEXT("PsnInfo"));
      if (PsnInfoValue.IsValid() && !PsnInfoValue->IsNull())
      {
          PsnInfo = MakeShareable(new FUserPsnInfo(PsnInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> SteamInfoValue = obj->TryGetField(TEXT("SteamInfo"));
      if (SteamInfoValue.IsValid() && !SteamInfoValue->IsNull())
      {
          SteamInfo = MakeShareable(new FUserSteamInfo(SteamInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> TitleInfoValue = obj->TryGetField(TEXT("TitleInfo"));
      if (TitleInfoValue.IsValid() && !TitleInfoValue->IsNull())
      {
          TitleInfo = MakeShareable(new FUserTitleInfo(TitleInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> TwitchInfoValue = obj->TryGetField(TEXT("TwitchInfo"));
      if (TwitchInfoValue.IsValid() && !TwitchInfoValue->IsNull())
      {
          TwitchInfo = MakeShareable(new FUserTwitchInfo(TwitchInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> UsernameValue = obj->TryGetField(TEXT("Username"));
      if (UsernameValue.IsValid() && !UsernameValue->IsNull())
      {
          FString TmpValue;
          if (UsernameValue->TryGetString(TmpValue)) { Username = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> WindowsHelloInfoValue = obj->TryGetField(TEXT("WindowsHelloInfo"));
      if (WindowsHelloInfoValue.IsValid() && !WindowsHelloInfoValue->IsNull())
      {
          WindowsHelloInfo = MakeShareable(new FUserWindowsHelloInfo(WindowsHelloInfoValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> XboxInfoValue = obj->TryGetField(TEXT("XboxInfo"));
      if (XboxInfoValue.IsValid() && !XboxInfoValue->IsNull())
      {
          XboxInfo = MakeShareable(new FUserXboxInfo(XboxInfoValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetAccountInfoResult::~FGetAccountInfoResult()
  {
      //if (AccountInfo != nullptr) delete AccountInfo;
  
  }
  
  void PlayFab::ClientModels::FGetAccountInfoResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AccountInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("AccountInfo")); AccountInfo->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetAccountInfoResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AccountInfoValue = obj->TryGetField(TEXT("AccountInfo"));
      if (AccountInfoValue.IsValid() && !AccountInfoValue->IsNull())
      {
          AccountInfo = MakeShareable(new FUserAccountInfo(AccountInfoValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetCatalogItemsRequest::~FGetCatalogItemsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetCatalogItemsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetCatalogItemsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetCatalogItemsResult::~FGetCatalogItemsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetCatalogItemsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Catalog.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Catalog"));
          for (const FCatalogItem& item : Catalog)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetCatalogItemsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&CatalogArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Catalog"));
      for (int32 Idx = 0; Idx < CatalogArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = CatalogArray[Idx];
          Catalog.Add(FCatalogItem(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetCharacterDataRequest::~FGetCharacterDataRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetCharacterDataRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId);
  
      if (IfChangedFromDataVersion.notNull()) { writer->WriteIdentifierPrefix(TEXT("IfChangedFromDataVersion")); writer->WriteValue(static_cast<int64>(IfChangedFromDataVersion)); }
  
      if (Keys.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Keys"));
          for (const FString& item : Keys)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetCharacterDataRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IfChangedFromDataVersionValue = obj->TryGetField(TEXT("IfChangedFromDataVersion"));
      if (IfChangedFromDataVersionValue.IsValid() && !IfChangedFromDataVersionValue->IsNull())
      {
          uint32 TmpValue;
          if (IfChangedFromDataVersionValue->TryGetNumber(TmpValue)) { IfChangedFromDataVersion = TmpValue; }
      }
  
      obj->TryGetStringArrayField(TEXT("Keys"), Keys);
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeUserDataPermissionEnumJSON(UserDataPermission enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case UserDataPermissionPrivate: writer->WriteValue(TEXT("Private")); break;
      case UserDataPermissionPublic: writer->WriteValue(TEXT("Public")); break;
      }
  }
  
  ClientModels::UserDataPermission PlayFab::ClientModels::readUserDataPermissionFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readUserDataPermissionFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::UserDataPermission PlayFab::ClientModels::readUserDataPermissionFromValue(const FString& value)
  {
      static TMap<FString, UserDataPermission> _UserDataPermissionMap;
      if (_UserDataPermissionMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _UserDataPermissionMap.Add(TEXT("Private"), UserDataPermissionPrivate);
          _UserDataPermissionMap.Add(TEXT("Public"), UserDataPermissionPublic);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _UserDataPermissionMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return UserDataPermissionPrivate; // Basically critical fail
  }
  
  PlayFab::ClientModels::FUserDataRecord::~FUserDataRecord()
  {
  
  }
  
  void PlayFab::ClientModels::FUserDataRecord::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("LastUpdated")); writeDatetime(LastUpdated, writer);
  
      if (Permission.notNull()) { writer->WriteIdentifierPrefix(TEXT("Permission")); writeUserDataPermissionEnumJSON(Permission, writer); }
  
      if (Value.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Value")); writer->WriteValue(Value); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserDataRecord::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> LastUpdatedValue = obj->TryGetField(TEXT("LastUpdated"));
      if (LastUpdatedValue.IsValid())
          LastUpdated = readDatetime(LastUpdatedValue);
  
  
      Permission = readUserDataPermissionFromValue(obj->TryGetField(TEXT("Permission")));
  
      const TSharedPtr<FJsonValue> ValueValue = obj->TryGetField(TEXT("Value"));
      if (ValueValue.IsValid() && !ValueValue->IsNull())
      {
          FString TmpValue;
          if (ValueValue->TryGetString(TmpValue)) { Value = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetCharacterDataResult::~FGetCharacterDataResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetCharacterDataResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      if (Data.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Data"));
          for (TMap<FString, FUserDataRecord>::TConstIterator It(Data); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteIdentifierPrefix(TEXT("DataVersion")); writer->WriteValue(static_cast<int64>(DataVersion));
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetCharacterDataResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonObject>* DataObject;
      if (obj->TryGetObjectField(TEXT("Data"), DataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*DataObject)->Values); It; ++It)
          {
              Data.Add(It.Key(), FUserDataRecord(It.Value()->AsObject()));
          }
      }
  
      const TSharedPtr<FJsonValue> DataVersionValue = obj->TryGetField(TEXT("DataVersion"));
      if (DataVersionValue.IsValid() && !DataVersionValue->IsNull())
      {
          uint32 TmpValue;
          if (DataVersionValue->TryGetNumber(TmpValue)) { DataVersion = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetCharacterInventoryRequest::~FGetCharacterInventoryRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetCharacterInventoryRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetCharacterInventoryRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FVirtualCurrencyRechargeTime::~FVirtualCurrencyRechargeTime()
  {
  
  }
  
  void PlayFab::ClientModels::FVirtualCurrencyRechargeTime::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("RechargeMax")); writer->WriteValue(RechargeMax);
  
      writer->WriteIdentifierPrefix(TEXT("RechargeTime")); writeDatetime(RechargeTime, writer);
  
      writer->WriteIdentifierPrefix(TEXT("SecondsToRecharge")); writer->WriteValue(SecondsToRecharge);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FVirtualCurrencyRechargeTime::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> RechargeMaxValue = obj->TryGetField(TEXT("RechargeMax"));
      if (RechargeMaxValue.IsValid() && !RechargeMaxValue->IsNull())
      {
          int32 TmpValue;
          if (RechargeMaxValue->TryGetNumber(TmpValue)) { RechargeMax = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> RechargeTimeValue = obj->TryGetField(TEXT("RechargeTime"));
      if (RechargeTimeValue.IsValid())
          RechargeTime = readDatetime(RechargeTimeValue);
  
  
      const TSharedPtr<FJsonValue> SecondsToRechargeValue = obj->TryGetField(TEXT("SecondsToRecharge"));
      if (SecondsToRechargeValue.IsValid() && !SecondsToRechargeValue->IsNull())
      {
          int32 TmpValue;
          if (SecondsToRechargeValue->TryGetNumber(TmpValue)) { SecondsToRecharge = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetCharacterInventoryResult::~FGetCharacterInventoryResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetCharacterInventoryResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      if (Inventory.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Inventory"));
          for (const FItemInstance& item : Inventory)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (VirtualCurrency.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VirtualCurrency"));
          for (TMap<FString, int32>::TConstIterator It(VirtualCurrency); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      if (VirtualCurrencyRechargeTimes.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VirtualCurrencyRechargeTimes"));
          for (TMap<FString, FVirtualCurrencyRechargeTime>::TConstIterator It(VirtualCurrencyRechargeTimes); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetCharacterInventoryResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TArray<TSharedPtr<FJsonValue>>&InventoryArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Inventory"));
      for (int32 Idx = 0; Idx < InventoryArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = InventoryArray[Idx];
          Inventory.Add(FItemInstance(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonObject>* VirtualCurrencyObject;
      if (obj->TryGetObjectField(TEXT("VirtualCurrency"), VirtualCurrencyObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VirtualCurrencyObject)->Values); It; ++It)
          {
              int32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              VirtualCurrency.Add(It.Key(), TmpValue);
          }
      }
  
      const TSharedPtr<FJsonObject>* VirtualCurrencyRechargeTimesObject;
      if (obj->TryGetObjectField(TEXT("VirtualCurrencyRechargeTimes"), VirtualCurrencyRechargeTimesObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VirtualCurrencyRechargeTimesObject)->Values); It; ++It)
          {
              VirtualCurrencyRechargeTimes.Add(It.Key(), FVirtualCurrencyRechargeTime(It.Value()->AsObject()));
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetCharacterLeaderboardRequest::~FGetCharacterLeaderboardRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetCharacterLeaderboardRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CharacterType.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterType")); writer->WriteValue(CharacterType); }
  
      if (MaxResultsCount.notNull()) { writer->WriteIdentifierPrefix(TEXT("MaxResultsCount")); writer->WriteValue(MaxResultsCount); }
  
      writer->WriteIdentifierPrefix(TEXT("StartPosition")); writer->WriteValue(StartPosition);
  
      writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetCharacterLeaderboardRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterTypeValue = obj->TryGetField(TEXT("CharacterType"));
      if (CharacterTypeValue.IsValid() && !CharacterTypeValue->IsNull())
      {
          FString TmpValue;
          if (CharacterTypeValue->TryGetString(TmpValue)) { CharacterType = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> MaxResultsCountValue = obj->TryGetField(TEXT("MaxResultsCount"));
      if (MaxResultsCountValue.IsValid() && !MaxResultsCountValue->IsNull())
      {
          int32 TmpValue;
          if (MaxResultsCountValue->TryGetNumber(TmpValue)) { MaxResultsCount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StartPositionValue = obj->TryGetField(TEXT("StartPosition"));
      if (StartPositionValue.IsValid() && !StartPositionValue->IsNull())
      {
          int32 TmpValue;
          if (StartPositionValue->TryGetNumber(TmpValue)) { StartPosition = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetCharacterLeaderboardResult::~FGetCharacterLeaderboardResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetCharacterLeaderboardResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Leaderboard.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Leaderboard"));
          for (const FCharacterLeaderboardEntry& item : Leaderboard)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetCharacterLeaderboardResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&LeaderboardArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Leaderboard"));
      for (int32 Idx = 0; Idx < LeaderboardArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = LeaderboardArray[Idx];
          Leaderboard.Add(FCharacterLeaderboardEntry(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetCharacterStatisticsRequest::~FGetCharacterStatisticsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetCharacterStatisticsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetCharacterStatisticsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetCharacterStatisticsResult::~FGetCharacterStatisticsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetCharacterStatisticsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CharacterStatistics.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("CharacterStatistics"));
          for (TMap<FString, int32>::TConstIterator It(CharacterStatistics); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetCharacterStatisticsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* CharacterStatisticsObject;
      if (obj->TryGetObjectField(TEXT("CharacterStatistics"), CharacterStatisticsObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*CharacterStatisticsObject)->Values); It; ++It)
          {
              int32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              CharacterStatistics.Add(It.Key(), TmpValue);
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetContentDownloadUrlRequest::~FGetContentDownloadUrlRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetContentDownloadUrlRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (HttpMethod.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("HttpMethod")); writer->WriteValue(HttpMethod); }
  
      writer->WriteIdentifierPrefix(TEXT("Key")); writer->WriteValue(Key);
  
      if (ThruCDN.notNull()) { writer->WriteIdentifierPrefix(TEXT("ThruCDN")); writer->WriteValue(ThruCDN); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetContentDownloadUrlRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> HttpMethodValue = obj->TryGetField(TEXT("HttpMethod"));
      if (HttpMethodValue.IsValid() && !HttpMethodValue->IsNull())
      {
          FString TmpValue;
          if (HttpMethodValue->TryGetString(TmpValue)) { HttpMethod = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> KeyValue = obj->TryGetField(TEXT("Key"));
      if (KeyValue.IsValid() && !KeyValue->IsNull())
      {
          FString TmpValue;
          if (KeyValue->TryGetString(TmpValue)) { Key = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ThruCDNValue = obj->TryGetField(TEXT("ThruCDN"));
      if (ThruCDNValue.IsValid() && !ThruCDNValue->IsNull())
      {
          bool TmpValue;
          if (ThruCDNValue->TryGetBool(TmpValue)) { ThruCDN = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetContentDownloadUrlResult::~FGetContentDownloadUrlResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetContentDownloadUrlResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (URL.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("URL")); writer->WriteValue(URL); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetContentDownloadUrlResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> URLValue = obj->TryGetField(TEXT("URL"));
      if (URLValue.IsValid() && !URLValue->IsNull())
      {
          FString TmpValue;
          if (URLValue->TryGetString(TmpValue)) { URL = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FPlayerProfileViewConstraints::~FPlayerProfileViewConstraints()
  {
  
  }
  
  void PlayFab::ClientModels::FPlayerProfileViewConstraints::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("ShowAvatarUrl")); writer->WriteValue(ShowAvatarUrl);
  
      writer->WriteIdentifierPrefix(TEXT("ShowBannedUntil")); writer->WriteValue(ShowBannedUntil);
  
      writer->WriteIdentifierPrefix(TEXT("ShowCampaignAttributions")); writer->WriteValue(ShowCampaignAttributions);
  
      writer->WriteIdentifierPrefix(TEXT("ShowContactEmailAddresses")); writer->WriteValue(ShowContactEmailAddresses);
  
      writer->WriteIdentifierPrefix(TEXT("ShowCreated")); writer->WriteValue(ShowCreated);
  
      writer->WriteIdentifierPrefix(TEXT("ShowDisplayName")); writer->WriteValue(ShowDisplayName);
  
      writer->WriteIdentifierPrefix(TEXT("ShowLastLogin")); writer->WriteValue(ShowLastLogin);
  
      writer->WriteIdentifierPrefix(TEXT("ShowLinkedAccounts")); writer->WriteValue(ShowLinkedAccounts);
  
      writer->WriteIdentifierPrefix(TEXT("ShowLocations")); writer->WriteValue(ShowLocations);
  
      writer->WriteIdentifierPrefix(TEXT("ShowMemberships")); writer->WriteValue(ShowMemberships);
  
      writer->WriteIdentifierPrefix(TEXT("ShowOrigination")); writer->WriteValue(ShowOrigination);
  
      writer->WriteIdentifierPrefix(TEXT("ShowPushNotificationRegistrations")); writer->WriteValue(ShowPushNotificationRegistrations);
  
      writer->WriteIdentifierPrefix(TEXT("ShowStatistics")); writer->WriteValue(ShowStatistics);
  
      writer->WriteIdentifierPrefix(TEXT("ShowTags")); writer->WriteValue(ShowTags);
  
      writer->WriteIdentifierPrefix(TEXT("ShowTotalValueToDateInUsd")); writer->WriteValue(ShowTotalValueToDateInUsd);
  
      writer->WriteIdentifierPrefix(TEXT("ShowValuesToDate")); writer->WriteValue(ShowValuesToDate);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPlayerProfileViewConstraints::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ShowAvatarUrlValue = obj->TryGetField(TEXT("ShowAvatarUrl"));
      if (ShowAvatarUrlValue.IsValid() && !ShowAvatarUrlValue->IsNull())
      {
          bool TmpValue;
          if (ShowAvatarUrlValue->TryGetBool(TmpValue)) { ShowAvatarUrl = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowBannedUntilValue = obj->TryGetField(TEXT("ShowBannedUntil"));
      if (ShowBannedUntilValue.IsValid() && !ShowBannedUntilValue->IsNull())
      {
          bool TmpValue;
          if (ShowBannedUntilValue->TryGetBool(TmpValue)) { ShowBannedUntil = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowCampaignAttributionsValue = obj->TryGetField(TEXT("ShowCampaignAttributions"));
      if (ShowCampaignAttributionsValue.IsValid() && !ShowCampaignAttributionsValue->IsNull())
      {
          bool TmpValue;
          if (ShowCampaignAttributionsValue->TryGetBool(TmpValue)) { ShowCampaignAttributions = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowContactEmailAddressesValue = obj->TryGetField(TEXT("ShowContactEmailAddresses"));
      if (ShowContactEmailAddressesValue.IsValid() && !ShowContactEmailAddressesValue->IsNull())
      {
          bool TmpValue;
          if (ShowContactEmailAddressesValue->TryGetBool(TmpValue)) { ShowContactEmailAddresses = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowCreatedValue = obj->TryGetField(TEXT("ShowCreated"));
      if (ShowCreatedValue.IsValid() && !ShowCreatedValue->IsNull())
      {
          bool TmpValue;
          if (ShowCreatedValue->TryGetBool(TmpValue)) { ShowCreated = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowDisplayNameValue = obj->TryGetField(TEXT("ShowDisplayName"));
      if (ShowDisplayNameValue.IsValid() && !ShowDisplayNameValue->IsNull())
      {
          bool TmpValue;
          if (ShowDisplayNameValue->TryGetBool(TmpValue)) { ShowDisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowLastLoginValue = obj->TryGetField(TEXT("ShowLastLogin"));
      if (ShowLastLoginValue.IsValid() && !ShowLastLoginValue->IsNull())
      {
          bool TmpValue;
          if (ShowLastLoginValue->TryGetBool(TmpValue)) { ShowLastLogin = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowLinkedAccountsValue = obj->TryGetField(TEXT("ShowLinkedAccounts"));
      if (ShowLinkedAccountsValue.IsValid() && !ShowLinkedAccountsValue->IsNull())
      {
          bool TmpValue;
          if (ShowLinkedAccountsValue->TryGetBool(TmpValue)) { ShowLinkedAccounts = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowLocationsValue = obj->TryGetField(TEXT("ShowLocations"));
      if (ShowLocationsValue.IsValid() && !ShowLocationsValue->IsNull())
      {
          bool TmpValue;
          if (ShowLocationsValue->TryGetBool(TmpValue)) { ShowLocations = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowMembershipsValue = obj->TryGetField(TEXT("ShowMemberships"));
      if (ShowMembershipsValue.IsValid() && !ShowMembershipsValue->IsNull())
      {
          bool TmpValue;
          if (ShowMembershipsValue->TryGetBool(TmpValue)) { ShowMemberships = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowOriginationValue = obj->TryGetField(TEXT("ShowOrigination"));
      if (ShowOriginationValue.IsValid() && !ShowOriginationValue->IsNull())
      {
          bool TmpValue;
          if (ShowOriginationValue->TryGetBool(TmpValue)) { ShowOrigination = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowPushNotificationRegistrationsValue = obj->TryGetField(TEXT("ShowPushNotificationRegistrations"));
      if (ShowPushNotificationRegistrationsValue.IsValid() && !ShowPushNotificationRegistrationsValue->IsNull())
      {
          bool TmpValue;
          if (ShowPushNotificationRegistrationsValue->TryGetBool(TmpValue)) { ShowPushNotificationRegistrations = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowStatisticsValue = obj->TryGetField(TEXT("ShowStatistics"));
      if (ShowStatisticsValue.IsValid() && !ShowStatisticsValue->IsNull())
      {
          bool TmpValue;
          if (ShowStatisticsValue->TryGetBool(TmpValue)) { ShowStatistics = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowTagsValue = obj->TryGetField(TEXT("ShowTags"));
      if (ShowTagsValue.IsValid() && !ShowTagsValue->IsNull())
      {
          bool TmpValue;
          if (ShowTagsValue->TryGetBool(TmpValue)) { ShowTags = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowTotalValueToDateInUsdValue = obj->TryGetField(TEXT("ShowTotalValueToDateInUsd"));
      if (ShowTotalValueToDateInUsdValue.IsValid() && !ShowTotalValueToDateInUsdValue->IsNull())
      {
          bool TmpValue;
          if (ShowTotalValueToDateInUsdValue->TryGetBool(TmpValue)) { ShowTotalValueToDateInUsd = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ShowValuesToDateValue = obj->TryGetField(TEXT("ShowValuesToDate"));
      if (ShowValuesToDateValue.IsValid() && !ShowValuesToDateValue->IsNull())
      {
          bool TmpValue;
          if (ShowValuesToDateValue->TryGetBool(TmpValue)) { ShowValuesToDate = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetFriendLeaderboardAroundPlayerRequest::~FGetFriendLeaderboardAroundPlayerRequest()
  {
      //if (ProfileConstraints != nullptr) delete ProfileConstraints;
  
  }
  
  void PlayFab::ClientModels::FGetFriendLeaderboardAroundPlayerRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (IncludeFacebookFriends.notNull()) { writer->WriteIdentifierPrefix(TEXT("IncludeFacebookFriends")); writer->WriteValue(IncludeFacebookFriends); }
  
      if (IncludeSteamFriends.notNull()) { writer->WriteIdentifierPrefix(TEXT("IncludeSteamFriends")); writer->WriteValue(IncludeSteamFriends); }
  
      if (MaxResultsCount.notNull()) { writer->WriteIdentifierPrefix(TEXT("MaxResultsCount")); writer->WriteValue(MaxResultsCount); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (ProfileConstraints.IsValid()) { writer->WriteIdentifierPrefix(TEXT("ProfileConstraints")); ProfileConstraints->writeJSON(writer); }
  
      writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName);
  
      if (UseSpecificVersion.notNull()) { writer->WriteIdentifierPrefix(TEXT("UseSpecificVersion")); writer->WriteValue(UseSpecificVersion); }
  
      if (Version.notNull()) { writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(Version); }
  
      if (XboxToken.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("XboxToken")); writer->WriteValue(XboxToken); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetFriendLeaderboardAroundPlayerRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> IncludeFacebookFriendsValue = obj->TryGetField(TEXT("IncludeFacebookFriends"));
      if (IncludeFacebookFriendsValue.IsValid() && !IncludeFacebookFriendsValue->IsNull())
      {
          bool TmpValue;
          if (IncludeFacebookFriendsValue->TryGetBool(TmpValue)) { IncludeFacebookFriends = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IncludeSteamFriendsValue = obj->TryGetField(TEXT("IncludeSteamFriends"));
      if (IncludeSteamFriendsValue.IsValid() && !IncludeSteamFriendsValue->IsNull())
      {
          bool TmpValue;
          if (IncludeSteamFriendsValue->TryGetBool(TmpValue)) { IncludeSteamFriends = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> MaxResultsCountValue = obj->TryGetField(TEXT("MaxResultsCount"));
      if (MaxResultsCountValue.IsValid() && !MaxResultsCountValue->IsNull())
      {
          int32 TmpValue;
          if (MaxResultsCountValue->TryGetNumber(TmpValue)) { MaxResultsCount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProfileConstraintsValue = obj->TryGetField(TEXT("ProfileConstraints"));
      if (ProfileConstraintsValue.IsValid() && !ProfileConstraintsValue->IsNull())
      {
          ProfileConstraints = MakeShareable(new FPlayerProfileViewConstraints(ProfileConstraintsValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UseSpecificVersionValue = obj->TryGetField(TEXT("UseSpecificVersion"));
      if (UseSpecificVersionValue.IsValid() && !UseSpecificVersionValue->IsNull())
      {
          bool TmpValue;
          if (UseSpecificVersionValue->TryGetBool(TmpValue)) { UseSpecificVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          int32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> XboxTokenValue = obj->TryGetField(TEXT("XboxToken"));
      if (XboxTokenValue.IsValid() && !XboxTokenValue->IsNull())
      {
          FString TmpValue;
          if (XboxTokenValue->TryGetString(TmpValue)) { XboxToken = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FPlayerLeaderboardEntry::~FPlayerLeaderboardEntry()
  {
      //if (Profile != nullptr) delete Profile;
  
  }
  
  void PlayFab::ClientModels::FPlayerLeaderboardEntry::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (DisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DisplayName")); writer->WriteValue(DisplayName); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteIdentifierPrefix(TEXT("Position")); writer->WriteValue(Position);
  
      if (Profile.IsValid()) { writer->WriteIdentifierPrefix(TEXT("Profile")); Profile->writeJSON(writer); }
  
      writer->WriteIdentifierPrefix(TEXT("StatValue")); writer->WriteValue(StatValue);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPlayerLeaderboardEntry::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DisplayNameValue = obj->TryGetField(TEXT("DisplayName"));
      if (DisplayNameValue.IsValid() && !DisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (DisplayNameValue->TryGetString(TmpValue)) { DisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PositionValue = obj->TryGetField(TEXT("Position"));
      if (PositionValue.IsValid() && !PositionValue->IsNull())
      {
          int32 TmpValue;
          if (PositionValue->TryGetNumber(TmpValue)) { Position = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProfileValue = obj->TryGetField(TEXT("Profile"));
      if (ProfileValue.IsValid() && !ProfileValue->IsNull())
      {
          Profile = MakeShareable(new FPlayerProfileModel(ProfileValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> StatValueValue = obj->TryGetField(TEXT("StatValue"));
      if (StatValueValue.IsValid() && !StatValueValue->IsNull())
      {
          int32 TmpValue;
          if (StatValueValue->TryGetNumber(TmpValue)) { StatValue = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetFriendLeaderboardAroundPlayerResult::~FGetFriendLeaderboardAroundPlayerResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetFriendLeaderboardAroundPlayerResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Leaderboard.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Leaderboard"));
          for (const FPlayerLeaderboardEntry& item : Leaderboard)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (NextReset.notNull()) { writer->WriteIdentifierPrefix(TEXT("NextReset")); writeDatetime(NextReset, writer); }
  
      writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(Version);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetFriendLeaderboardAroundPlayerResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&LeaderboardArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Leaderboard"));
      for (int32 Idx = 0; Idx < LeaderboardArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = LeaderboardArray[Idx];
          Leaderboard.Add(FPlayerLeaderboardEntry(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> NextResetValue = obj->TryGetField(TEXT("NextReset"));
      if (NextResetValue.IsValid())
          NextReset = readDatetime(NextResetValue);
  
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          int32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetFriendLeaderboardRequest::~FGetFriendLeaderboardRequest()
  {
      //if (ProfileConstraints != nullptr) delete ProfileConstraints;
  
  }
  
  void PlayFab::ClientModels::FGetFriendLeaderboardRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (IncludeFacebookFriends.notNull()) { writer->WriteIdentifierPrefix(TEXT("IncludeFacebookFriends")); writer->WriteValue(IncludeFacebookFriends); }
  
      if (IncludeSteamFriends.notNull()) { writer->WriteIdentifierPrefix(TEXT("IncludeSteamFriends")); writer->WriteValue(IncludeSteamFriends); }
  
      if (MaxResultsCount.notNull()) { writer->WriteIdentifierPrefix(TEXT("MaxResultsCount")); writer->WriteValue(MaxResultsCount); }
  
      if (ProfileConstraints.IsValid()) { writer->WriteIdentifierPrefix(TEXT("ProfileConstraints")); ProfileConstraints->writeJSON(writer); }
  
      writer->WriteIdentifierPrefix(TEXT("StartPosition")); writer->WriteValue(StartPosition);
  
      writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName);
  
      if (UseSpecificVersion.notNull()) { writer->WriteIdentifierPrefix(TEXT("UseSpecificVersion")); writer->WriteValue(UseSpecificVersion); }
  
      if (Version.notNull()) { writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(Version); }
  
      if (XboxToken.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("XboxToken")); writer->WriteValue(XboxToken); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetFriendLeaderboardRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> IncludeFacebookFriendsValue = obj->TryGetField(TEXT("IncludeFacebookFriends"));
      if (IncludeFacebookFriendsValue.IsValid() && !IncludeFacebookFriendsValue->IsNull())
      {
          bool TmpValue;
          if (IncludeFacebookFriendsValue->TryGetBool(TmpValue)) { IncludeFacebookFriends = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IncludeSteamFriendsValue = obj->TryGetField(TEXT("IncludeSteamFriends"));
      if (IncludeSteamFriendsValue.IsValid() && !IncludeSteamFriendsValue->IsNull())
      {
          bool TmpValue;
          if (IncludeSteamFriendsValue->TryGetBool(TmpValue)) { IncludeSteamFriends = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> MaxResultsCountValue = obj->TryGetField(TEXT("MaxResultsCount"));
      if (MaxResultsCountValue.IsValid() && !MaxResultsCountValue->IsNull())
      {
          int32 TmpValue;
          if (MaxResultsCountValue->TryGetNumber(TmpValue)) { MaxResultsCount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProfileConstraintsValue = obj->TryGetField(TEXT("ProfileConstraints"));
      if (ProfileConstraintsValue.IsValid() && !ProfileConstraintsValue->IsNull())
      {
          ProfileConstraints = MakeShareable(new FPlayerProfileViewConstraints(ProfileConstraintsValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> StartPositionValue = obj->TryGetField(TEXT("StartPosition"));
      if (StartPositionValue.IsValid() && !StartPositionValue->IsNull())
      {
          int32 TmpValue;
          if (StartPositionValue->TryGetNumber(TmpValue)) { StartPosition = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UseSpecificVersionValue = obj->TryGetField(TEXT("UseSpecificVersion"));
      if (UseSpecificVersionValue.IsValid() && !UseSpecificVersionValue->IsNull())
      {
          bool TmpValue;
          if (UseSpecificVersionValue->TryGetBool(TmpValue)) { UseSpecificVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          int32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> XboxTokenValue = obj->TryGetField(TEXT("XboxToken"));
      if (XboxTokenValue.IsValid() && !XboxTokenValue->IsNull())
      {
          FString TmpValue;
          if (XboxTokenValue->TryGetString(TmpValue)) { XboxToken = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetFriendsListRequest::~FGetFriendsListRequest()
  {
      //if (ProfileConstraints != nullptr) delete ProfileConstraints;
  
  }
  
  void PlayFab::ClientModels::FGetFriendsListRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (IncludeFacebookFriends.notNull()) { writer->WriteIdentifierPrefix(TEXT("IncludeFacebookFriends")); writer->WriteValue(IncludeFacebookFriends); }
  
      if (IncludeSteamFriends.notNull()) { writer->WriteIdentifierPrefix(TEXT("IncludeSteamFriends")); writer->WriteValue(IncludeSteamFriends); }
  
      if (ProfileConstraints.IsValid()) { writer->WriteIdentifierPrefix(TEXT("ProfileConstraints")); ProfileConstraints->writeJSON(writer); }
  
      if (XboxToken.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("XboxToken")); writer->WriteValue(XboxToken); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetFriendsListRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> IncludeFacebookFriendsValue = obj->TryGetField(TEXT("IncludeFacebookFriends"));
      if (IncludeFacebookFriendsValue.IsValid() && !IncludeFacebookFriendsValue->IsNull())
      {
          bool TmpValue;
          if (IncludeFacebookFriendsValue->TryGetBool(TmpValue)) { IncludeFacebookFriends = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IncludeSteamFriendsValue = obj->TryGetField(TEXT("IncludeSteamFriends"));
      if (IncludeSteamFriendsValue.IsValid() && !IncludeSteamFriendsValue->IsNull())
      {
          bool TmpValue;
          if (IncludeSteamFriendsValue->TryGetBool(TmpValue)) { IncludeSteamFriends = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProfileConstraintsValue = obj->TryGetField(TEXT("ProfileConstraints"));
      if (ProfileConstraintsValue.IsValid() && !ProfileConstraintsValue->IsNull())
      {
          ProfileConstraints = MakeShareable(new FPlayerProfileViewConstraints(ProfileConstraintsValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> XboxTokenValue = obj->TryGetField(TEXT("XboxToken"));
      if (XboxTokenValue.IsValid() && !XboxTokenValue->IsNull())
      {
          FString TmpValue;
          if (XboxTokenValue->TryGetString(TmpValue)) { XboxToken = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetFriendsListResult::~FGetFriendsListResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetFriendsListResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Friends.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Friends"));
          for (const FFriendInfo& item : Friends)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetFriendsListResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&FriendsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Friends"));
      for (int32 Idx = 0; Idx < FriendsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = FriendsArray[Idx];
          Friends.Add(FFriendInfo(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetLeaderboardAroundCharacterRequest::~FGetLeaderboardAroundCharacterRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetLeaderboardAroundCharacterRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId);
  
      if (CharacterType.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterType")); writer->WriteValue(CharacterType); }
  
      if (MaxResultsCount.notNull()) { writer->WriteIdentifierPrefix(TEXT("MaxResultsCount")); writer->WriteValue(MaxResultsCount); }
  
      writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetLeaderboardAroundCharacterRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterTypeValue = obj->TryGetField(TEXT("CharacterType"));
      if (CharacterTypeValue.IsValid() && !CharacterTypeValue->IsNull())
      {
          FString TmpValue;
          if (CharacterTypeValue->TryGetString(TmpValue)) { CharacterType = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> MaxResultsCountValue = obj->TryGetField(TEXT("MaxResultsCount"));
      if (MaxResultsCountValue.IsValid() && !MaxResultsCountValue->IsNull())
      {
          int32 TmpValue;
          if (MaxResultsCountValue->TryGetNumber(TmpValue)) { MaxResultsCount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetLeaderboardAroundCharacterResult::~FGetLeaderboardAroundCharacterResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetLeaderboardAroundCharacterResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Leaderboard.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Leaderboard"));
          for (const FCharacterLeaderboardEntry& item : Leaderboard)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetLeaderboardAroundCharacterResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&LeaderboardArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Leaderboard"));
      for (int32 Idx = 0; Idx < LeaderboardArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = LeaderboardArray[Idx];
          Leaderboard.Add(FCharacterLeaderboardEntry(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetLeaderboardAroundPlayerRequest::~FGetLeaderboardAroundPlayerRequest()
  {
      //if (ProfileConstraints != nullptr) delete ProfileConstraints;
  
  }
  
  void PlayFab::ClientModels::FGetLeaderboardAroundPlayerRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (MaxResultsCount.notNull()) { writer->WriteIdentifierPrefix(TEXT("MaxResultsCount")); writer->WriteValue(MaxResultsCount); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (ProfileConstraints.IsValid()) { writer->WriteIdentifierPrefix(TEXT("ProfileConstraints")); ProfileConstraints->writeJSON(writer); }
  
      writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName);
  
      if (UseSpecificVersion.notNull()) { writer->WriteIdentifierPrefix(TEXT("UseSpecificVersion")); writer->WriteValue(UseSpecificVersion); }
  
      if (Version.notNull()) { writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(Version); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetLeaderboardAroundPlayerRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> MaxResultsCountValue = obj->TryGetField(TEXT("MaxResultsCount"));
      if (MaxResultsCountValue.IsValid() && !MaxResultsCountValue->IsNull())
      {
          int32 TmpValue;
          if (MaxResultsCountValue->TryGetNumber(TmpValue)) { MaxResultsCount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProfileConstraintsValue = obj->TryGetField(TEXT("ProfileConstraints"));
      if (ProfileConstraintsValue.IsValid() && !ProfileConstraintsValue->IsNull())
      {
          ProfileConstraints = MakeShareable(new FPlayerProfileViewConstraints(ProfileConstraintsValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UseSpecificVersionValue = obj->TryGetField(TEXT("UseSpecificVersion"));
      if (UseSpecificVersionValue.IsValid() && !UseSpecificVersionValue->IsNull())
      {
          bool TmpValue;
          if (UseSpecificVersionValue->TryGetBool(TmpValue)) { UseSpecificVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          int32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetLeaderboardAroundPlayerResult::~FGetLeaderboardAroundPlayerResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetLeaderboardAroundPlayerResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Leaderboard.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Leaderboard"));
          for (const FPlayerLeaderboardEntry& item : Leaderboard)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (NextReset.notNull()) { writer->WriteIdentifierPrefix(TEXT("NextReset")); writeDatetime(NextReset, writer); }
  
      writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(Version);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetLeaderboardAroundPlayerResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&LeaderboardArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Leaderboard"));
      for (int32 Idx = 0; Idx < LeaderboardArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = LeaderboardArray[Idx];
          Leaderboard.Add(FPlayerLeaderboardEntry(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> NextResetValue = obj->TryGetField(TEXT("NextReset"));
      if (NextResetValue.IsValid())
          NextReset = readDatetime(NextResetValue);
  
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          int32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetLeaderboardForUsersCharactersRequest::~FGetLeaderboardForUsersCharactersRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetLeaderboardForUsersCharactersRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("MaxResultsCount")); writer->WriteValue(MaxResultsCount);
  
      writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetLeaderboardForUsersCharactersRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> MaxResultsCountValue = obj->TryGetField(TEXT("MaxResultsCount"));
      if (MaxResultsCountValue.IsValid() && !MaxResultsCountValue->IsNull())
      {
          int32 TmpValue;
          if (MaxResultsCountValue->TryGetNumber(TmpValue)) { MaxResultsCount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetLeaderboardForUsersCharactersResult::~FGetLeaderboardForUsersCharactersResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetLeaderboardForUsersCharactersResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Leaderboard.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Leaderboard"));
          for (const FCharacterLeaderboardEntry& item : Leaderboard)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetLeaderboardForUsersCharactersResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&LeaderboardArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Leaderboard"));
      for (int32 Idx = 0; Idx < LeaderboardArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = LeaderboardArray[Idx];
          Leaderboard.Add(FCharacterLeaderboardEntry(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetLeaderboardRequest::~FGetLeaderboardRequest()
  {
      //if (ProfileConstraints != nullptr) delete ProfileConstraints;
  
  }
  
  void PlayFab::ClientModels::FGetLeaderboardRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (MaxResultsCount.notNull()) { writer->WriteIdentifierPrefix(TEXT("MaxResultsCount")); writer->WriteValue(MaxResultsCount); }
  
      if (ProfileConstraints.IsValid()) { writer->WriteIdentifierPrefix(TEXT("ProfileConstraints")); ProfileConstraints->writeJSON(writer); }
  
      writer->WriteIdentifierPrefix(TEXT("StartPosition")); writer->WriteValue(StartPosition);
  
      writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName);
  
      if (UseSpecificVersion.notNull()) { writer->WriteIdentifierPrefix(TEXT("UseSpecificVersion")); writer->WriteValue(UseSpecificVersion); }
  
      if (Version.notNull()) { writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(Version); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetLeaderboardRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> MaxResultsCountValue = obj->TryGetField(TEXT("MaxResultsCount"));
      if (MaxResultsCountValue.IsValid() && !MaxResultsCountValue->IsNull())
      {
          int32 TmpValue;
          if (MaxResultsCountValue->TryGetNumber(TmpValue)) { MaxResultsCount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProfileConstraintsValue = obj->TryGetField(TEXT("ProfileConstraints"));
      if (ProfileConstraintsValue.IsValid() && !ProfileConstraintsValue->IsNull())
      {
          ProfileConstraints = MakeShareable(new FPlayerProfileViewConstraints(ProfileConstraintsValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> StartPositionValue = obj->TryGetField(TEXT("StartPosition"));
      if (StartPositionValue.IsValid() && !StartPositionValue->IsNull())
      {
          int32 TmpValue;
          if (StartPositionValue->TryGetNumber(TmpValue)) { StartPosition = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UseSpecificVersionValue = obj->TryGetField(TEXT("UseSpecificVersion"));
      if (UseSpecificVersionValue.IsValid() && !UseSpecificVersionValue->IsNull())
      {
          bool TmpValue;
          if (UseSpecificVersionValue->TryGetBool(TmpValue)) { UseSpecificVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          int32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetLeaderboardResult::~FGetLeaderboardResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetLeaderboardResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Leaderboard.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Leaderboard"));
          for (const FPlayerLeaderboardEntry& item : Leaderboard)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (NextReset.notNull()) { writer->WriteIdentifierPrefix(TEXT("NextReset")); writeDatetime(NextReset, writer); }
  
      writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(Version);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetLeaderboardResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&LeaderboardArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Leaderboard"));
      for (int32 Idx = 0; Idx < LeaderboardArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = LeaderboardArray[Idx];
          Leaderboard.Add(FPlayerLeaderboardEntry(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> NextResetValue = obj->TryGetField(TEXT("NextReset"));
      if (NextResetValue.IsValid())
          NextReset = readDatetime(NextResetValue);
  
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          int32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPaymentTokenRequest::~FGetPaymentTokenRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPaymentTokenRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("TokenProvider")); writer->WriteValue(TokenProvider);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPaymentTokenRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> TokenProviderValue = obj->TryGetField(TEXT("TokenProvider"));
      if (TokenProviderValue.IsValid() && !TokenProviderValue->IsNull())
      {
          FString TmpValue;
          if (TokenProviderValue->TryGetString(TmpValue)) { TokenProvider = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPaymentTokenResult::~FGetPaymentTokenResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPaymentTokenResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (OrderId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("OrderId")); writer->WriteValue(OrderId); }
  
      if (ProviderToken.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ProviderToken")); writer->WriteValue(ProviderToken); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPaymentTokenResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> OrderIdValue = obj->TryGetField(TEXT("OrderId"));
      if (OrderIdValue.IsValid() && !OrderIdValue->IsNull())
      {
          FString TmpValue;
          if (OrderIdValue->TryGetString(TmpValue)) { OrderId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProviderTokenValue = obj->TryGetField(TEXT("ProviderToken"));
      if (ProviderTokenValue.IsValid() && !ProviderTokenValue->IsNull())
      {
          FString TmpValue;
          if (ProviderTokenValue->TryGetString(TmpValue)) { ProviderToken = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPhotonAuthenticationTokenRequest::~FGetPhotonAuthenticationTokenRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPhotonAuthenticationTokenRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("PhotonApplicationId")); writer->WriteValue(PhotonApplicationId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPhotonAuthenticationTokenRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PhotonApplicationIdValue = obj->TryGetField(TEXT("PhotonApplicationId"));
      if (PhotonApplicationIdValue.IsValid() && !PhotonApplicationIdValue->IsNull())
      {
          FString TmpValue;
          if (PhotonApplicationIdValue->TryGetString(TmpValue)) { PhotonApplicationId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPhotonAuthenticationTokenResult::~FGetPhotonAuthenticationTokenResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPhotonAuthenticationTokenResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (PhotonCustomAuthenticationToken.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PhotonCustomAuthenticationToken")); writer->WriteValue(PhotonCustomAuthenticationToken); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPhotonAuthenticationTokenResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PhotonCustomAuthenticationTokenValue = obj->TryGetField(TEXT("PhotonCustomAuthenticationToken"));
      if (PhotonCustomAuthenticationTokenValue.IsValid() && !PhotonCustomAuthenticationTokenValue->IsNull())
      {
          FString TmpValue;
          if (PhotonCustomAuthenticationTokenValue->TryGetString(TmpValue)) { PhotonCustomAuthenticationToken = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerCombinedInfoRequestParams::~FGetPlayerCombinedInfoRequestParams()
  {
      //if (ProfileConstraints != nullptr) delete ProfileConstraints;
  
  }
  
  void PlayFab::ClientModels::FGetPlayerCombinedInfoRequestParams::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("GetCharacterInventories")); writer->WriteValue(GetCharacterInventories);
  
      writer->WriteIdentifierPrefix(TEXT("GetCharacterList")); writer->WriteValue(GetCharacterList);
  
      writer->WriteIdentifierPrefix(TEXT("GetPlayerProfile")); writer->WriteValue(GetPlayerProfile);
  
      writer->WriteIdentifierPrefix(TEXT("GetPlayerStatistics")); writer->WriteValue(GetPlayerStatistics);
  
      writer->WriteIdentifierPrefix(TEXT("GetTitleData")); writer->WriteValue(GetTitleData);
  
      writer->WriteIdentifierPrefix(TEXT("GetUserAccountInfo")); writer->WriteValue(GetUserAccountInfo);
  
      writer->WriteIdentifierPrefix(TEXT("GetUserData")); writer->WriteValue(GetUserData);
  
      writer->WriteIdentifierPrefix(TEXT("GetUserInventory")); writer->WriteValue(GetUserInventory);
  
      writer->WriteIdentifierPrefix(TEXT("GetUserReadOnlyData")); writer->WriteValue(GetUserReadOnlyData);
  
      writer->WriteIdentifierPrefix(TEXT("GetUserVirtualCurrency")); writer->WriteValue(GetUserVirtualCurrency);
  
      if (PlayerStatisticNames.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("PlayerStatisticNames"));
          for (const FString& item : PlayerStatisticNames)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (ProfileConstraints.IsValid()) { writer->WriteIdentifierPrefix(TEXT("ProfileConstraints")); ProfileConstraints->writeJSON(writer); }
  
      if (TitleDataKeys.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("TitleDataKeys"));
          for (const FString& item : TitleDataKeys)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (UserDataKeys.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("UserDataKeys"));
          for (const FString& item : UserDataKeys)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (UserReadOnlyDataKeys.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("UserReadOnlyDataKeys"));
          for (const FString& item : UserReadOnlyDataKeys)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerCombinedInfoRequestParams::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> GetCharacterInventoriesValue = obj->TryGetField(TEXT("GetCharacterInventories"));
      if (GetCharacterInventoriesValue.IsValid() && !GetCharacterInventoriesValue->IsNull())
      {
          bool TmpValue;
          if (GetCharacterInventoriesValue->TryGetBool(TmpValue)) { GetCharacterInventories = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GetCharacterListValue = obj->TryGetField(TEXT("GetCharacterList"));
      if (GetCharacterListValue.IsValid() && !GetCharacterListValue->IsNull())
      {
          bool TmpValue;
          if (GetCharacterListValue->TryGetBool(TmpValue)) { GetCharacterList = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GetPlayerProfileValue = obj->TryGetField(TEXT("GetPlayerProfile"));
      if (GetPlayerProfileValue.IsValid() && !GetPlayerProfileValue->IsNull())
      {
          bool TmpValue;
          if (GetPlayerProfileValue->TryGetBool(TmpValue)) { GetPlayerProfile = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GetPlayerStatisticsValue = obj->TryGetField(TEXT("GetPlayerStatistics"));
      if (GetPlayerStatisticsValue.IsValid() && !GetPlayerStatisticsValue->IsNull())
      {
          bool TmpValue;
          if (GetPlayerStatisticsValue->TryGetBool(TmpValue)) { GetPlayerStatistics = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GetTitleDataValue = obj->TryGetField(TEXT("GetTitleData"));
      if (GetTitleDataValue.IsValid() && !GetTitleDataValue->IsNull())
      {
          bool TmpValue;
          if (GetTitleDataValue->TryGetBool(TmpValue)) { GetTitleData = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GetUserAccountInfoValue = obj->TryGetField(TEXT("GetUserAccountInfo"));
      if (GetUserAccountInfoValue.IsValid() && !GetUserAccountInfoValue->IsNull())
      {
          bool TmpValue;
          if (GetUserAccountInfoValue->TryGetBool(TmpValue)) { GetUserAccountInfo = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GetUserDataValue = obj->TryGetField(TEXT("GetUserData"));
      if (GetUserDataValue.IsValid() && !GetUserDataValue->IsNull())
      {
          bool TmpValue;
          if (GetUserDataValue->TryGetBool(TmpValue)) { GetUserData = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GetUserInventoryValue = obj->TryGetField(TEXT("GetUserInventory"));
      if (GetUserInventoryValue.IsValid() && !GetUserInventoryValue->IsNull())
      {
          bool TmpValue;
          if (GetUserInventoryValue->TryGetBool(TmpValue)) { GetUserInventory = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GetUserReadOnlyDataValue = obj->TryGetField(TEXT("GetUserReadOnlyData"));
      if (GetUserReadOnlyDataValue.IsValid() && !GetUserReadOnlyDataValue->IsNull())
      {
          bool TmpValue;
          if (GetUserReadOnlyDataValue->TryGetBool(TmpValue)) { GetUserReadOnlyData = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GetUserVirtualCurrencyValue = obj->TryGetField(TEXT("GetUserVirtualCurrency"));
      if (GetUserVirtualCurrencyValue.IsValid() && !GetUserVirtualCurrencyValue->IsNull())
      {
          bool TmpValue;
          if (GetUserVirtualCurrencyValue->TryGetBool(TmpValue)) { GetUserVirtualCurrency = TmpValue; }
      }
  
      obj->TryGetStringArrayField(TEXT("PlayerStatisticNames"), PlayerStatisticNames);
  
      const TSharedPtr<FJsonValue> ProfileConstraintsValue = obj->TryGetField(TEXT("ProfileConstraints"));
      if (ProfileConstraintsValue.IsValid() && !ProfileConstraintsValue->IsNull())
      {
          ProfileConstraints = MakeShareable(new FPlayerProfileViewConstraints(ProfileConstraintsValue->AsObject()));
      }
  
      obj->TryGetStringArrayField(TEXT("TitleDataKeys"), TitleDataKeys);
  
      obj->TryGetStringArrayField(TEXT("UserDataKeys"), UserDataKeys);
  
      obj->TryGetStringArrayField(TEXT("UserReadOnlyDataKeys"), UserReadOnlyDataKeys);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerCombinedInfoRequest::~FGetPlayerCombinedInfoRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayerCombinedInfoRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters.writeJSON(writer);
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerCombinedInfoRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject());
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FStatisticValue::~FStatisticValue()
  {
  
  }
  
  void PlayFab::ClientModels::FStatisticValue::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (StatisticName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName); }
  
      writer->WriteIdentifierPrefix(TEXT("Value")); writer->WriteValue(Value);
  
      writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(static_cast<int64>(Version));
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FStatisticValue::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ValueValue = obj->TryGetField(TEXT("Value"));
      if (ValueValue.IsValid() && !ValueValue->IsNull())
      {
          int32 TmpValue;
          if (ValueValue->TryGetNumber(TmpValue)) { Value = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          uint32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerCombinedInfoResultPayload::~FGetPlayerCombinedInfoResultPayload()
  {
      //if (AccountInfo != nullptr) delete AccountInfo;
      //if (PlayerProfile != nullptr) delete PlayerProfile;
  
  }
  
  void PlayFab::ClientModels::FGetPlayerCombinedInfoResultPayload::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AccountInfo.IsValid()) { writer->WriteIdentifierPrefix(TEXT("AccountInfo")); AccountInfo->writeJSON(writer); }
  
      if (CharacterInventories.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("CharacterInventories"));
          for (const FCharacterInventory& item : CharacterInventories)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (CharacterList.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("CharacterList"));
          for (const FCharacterResult& item : CharacterList)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (PlayerProfile.IsValid()) { writer->WriteIdentifierPrefix(TEXT("PlayerProfile")); PlayerProfile->writeJSON(writer); }
  
      if (PlayerStatistics.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("PlayerStatistics"));
          for (const FStatisticValue& item : PlayerStatistics)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (TitleData.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("TitleData"));
          for (TMap<FString, FString>::TConstIterator It(TitleData); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      if (UserData.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("UserData"));
          for (TMap<FString, FUserDataRecord>::TConstIterator It(UserData); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteIdentifierPrefix(TEXT("UserDataVersion")); writer->WriteValue(static_cast<int64>(UserDataVersion));
  
      if (UserInventory.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("UserInventory"));
          for (const FItemInstance& item : UserInventory)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (UserReadOnlyData.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("UserReadOnlyData"));
          for (TMap<FString, FUserDataRecord>::TConstIterator It(UserReadOnlyData); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteIdentifierPrefix(TEXT("UserReadOnlyDataVersion")); writer->WriteValue(static_cast<int64>(UserReadOnlyDataVersion));
  
      if (UserVirtualCurrency.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("UserVirtualCurrency"));
          for (TMap<FString, int32>::TConstIterator It(UserVirtualCurrency); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      if (UserVirtualCurrencyRechargeTimes.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("UserVirtualCurrencyRechargeTimes"));
          for (TMap<FString, FVirtualCurrencyRechargeTime>::TConstIterator It(UserVirtualCurrencyRechargeTimes); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerCombinedInfoResultPayload::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AccountInfoValue = obj->TryGetField(TEXT("AccountInfo"));
      if (AccountInfoValue.IsValid() && !AccountInfoValue->IsNull())
      {
          AccountInfo = MakeShareable(new FUserAccountInfo(AccountInfoValue->AsObject()));
      }
  
      const TArray<TSharedPtr<FJsonValue>>&CharacterInventoriesArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("CharacterInventories"));
      for (int32 Idx = 0; Idx < CharacterInventoriesArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = CharacterInventoriesArray[Idx];
          CharacterInventories.Add(FCharacterInventory(CurrentItem->AsObject()));
      }
  
  
      const TArray<TSharedPtr<FJsonValue>>&CharacterListArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("CharacterList"));
      for (int32 Idx = 0; Idx < CharacterListArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = CharacterListArray[Idx];
          CharacterList.Add(FCharacterResult(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> PlayerProfileValue = obj->TryGetField(TEXT("PlayerProfile"));
      if (PlayerProfileValue.IsValid() && !PlayerProfileValue->IsNull())
      {
          PlayerProfile = MakeShareable(new FPlayerProfileModel(PlayerProfileValue->AsObject()));
      }
  
      const TArray<TSharedPtr<FJsonValue>>&PlayerStatisticsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("PlayerStatistics"));
      for (int32 Idx = 0; Idx < PlayerStatisticsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = PlayerStatisticsArray[Idx];
          PlayerStatistics.Add(FStatisticValue(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonObject>* TitleDataObject;
      if (obj->TryGetObjectField(TEXT("TitleData"), TitleDataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*TitleDataObject)->Values); It; ++It)
          {
              TitleData.Add(It.Key(), It.Value()->AsString());
          }
      }
  
      const TSharedPtr<FJsonObject>* UserDataObject;
      if (obj->TryGetObjectField(TEXT("UserData"), UserDataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*UserDataObject)->Values); It; ++It)
          {
              UserData.Add(It.Key(), FUserDataRecord(It.Value()->AsObject()));
          }
      }
  
      const TSharedPtr<FJsonValue> UserDataVersionValue = obj->TryGetField(TEXT("UserDataVersion"));
      if (UserDataVersionValue.IsValid() && !UserDataVersionValue->IsNull())
      {
          uint32 TmpValue;
          if (UserDataVersionValue->TryGetNumber(TmpValue)) { UserDataVersion = TmpValue; }
      }
  
      const TArray<TSharedPtr<FJsonValue>>&UserInventoryArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("UserInventory"));
      for (int32 Idx = 0; Idx < UserInventoryArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = UserInventoryArray[Idx];
          UserInventory.Add(FItemInstance(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonObject>* UserReadOnlyDataObject;
      if (obj->TryGetObjectField(TEXT("UserReadOnlyData"), UserReadOnlyDataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*UserReadOnlyDataObject)->Values); It; ++It)
          {
              UserReadOnlyData.Add(It.Key(), FUserDataRecord(It.Value()->AsObject()));
          }
      }
  
      const TSharedPtr<FJsonValue> UserReadOnlyDataVersionValue = obj->TryGetField(TEXT("UserReadOnlyDataVersion"));
      if (UserReadOnlyDataVersionValue.IsValid() && !UserReadOnlyDataVersionValue->IsNull())
      {
          uint32 TmpValue;
          if (UserReadOnlyDataVersionValue->TryGetNumber(TmpValue)) { UserReadOnlyDataVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonObject>* UserVirtualCurrencyObject;
      if (obj->TryGetObjectField(TEXT("UserVirtualCurrency"), UserVirtualCurrencyObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*UserVirtualCurrencyObject)->Values); It; ++It)
          {
              int32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              UserVirtualCurrency.Add(It.Key(), TmpValue);
          }
      }
  
      const TSharedPtr<FJsonObject>* UserVirtualCurrencyRechargeTimesObject;
      if (obj->TryGetObjectField(TEXT("UserVirtualCurrencyRechargeTimes"), UserVirtualCurrencyRechargeTimesObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*UserVirtualCurrencyRechargeTimesObject)->Values); It; ++It)
          {
              UserVirtualCurrencyRechargeTimes.Add(It.Key(), FVirtualCurrencyRechargeTime(It.Value()->AsObject()));
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerCombinedInfoResult::~FGetPlayerCombinedInfoResult()
  {
      //if (InfoResultPayload != nullptr) delete InfoResultPayload;
  
  }
  
  void PlayFab::ClientModels::FGetPlayerCombinedInfoResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (InfoResultPayload.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoResultPayload")); InfoResultPayload->writeJSON(writer); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerCombinedInfoResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> InfoResultPayloadValue = obj->TryGetField(TEXT("InfoResultPayload"));
      if (InfoResultPayloadValue.IsValid() && !InfoResultPayloadValue->IsNull())
      {
          InfoResultPayload = MakeShareable(new FGetPlayerCombinedInfoResultPayload(InfoResultPayloadValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerProfileRequest::~FGetPlayerProfileRequest()
  {
      //if (ProfileConstraints != nullptr) delete ProfileConstraints;
  
  }
  
  void PlayFab::ClientModels::FGetPlayerProfileRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (ProfileConstraints.IsValid()) { writer->WriteIdentifierPrefix(TEXT("ProfileConstraints")); ProfileConstraints->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerProfileRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProfileConstraintsValue = obj->TryGetField(TEXT("ProfileConstraints"));
      if (ProfileConstraintsValue.IsValid() && !ProfileConstraintsValue->IsNull())
      {
          ProfileConstraints = MakeShareable(new FPlayerProfileViewConstraints(ProfileConstraintsValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerProfileResult::~FGetPlayerProfileResult()
  {
      //if (PlayerProfile != nullptr) delete PlayerProfile;
  
  }
  
  void PlayFab::ClientModels::FGetPlayerProfileResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (PlayerProfile.IsValid()) { writer->WriteIdentifierPrefix(TEXT("PlayerProfile")); PlayerProfile->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerProfileResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PlayerProfileValue = obj->TryGetField(TEXT("PlayerProfile"));
      if (PlayerProfileValue.IsValid() && !PlayerProfileValue->IsNull())
      {
          PlayerProfile = MakeShareable(new FPlayerProfileModel(PlayerProfileValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerSegmentsRequest::~FGetPlayerSegmentsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayerSegmentsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerSegmentsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetSegmentResult::~FGetSegmentResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetSegmentResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ABTestParent.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ABTestParent")); writer->WriteValue(ABTestParent); }
  
      writer->WriteIdentifierPrefix(TEXT("Id")); writer->WriteValue(Id);
  
      if (Name.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Name")); writer->WriteValue(Name); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetSegmentResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ABTestParentValue = obj->TryGetField(TEXT("ABTestParent"));
      if (ABTestParentValue.IsValid() && !ABTestParentValue->IsNull())
      {
          FString TmpValue;
          if (ABTestParentValue->TryGetString(TmpValue)) { ABTestParent = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IdValue = obj->TryGetField(TEXT("Id"));
      if (IdValue.IsValid() && !IdValue->IsNull())
      {
          FString TmpValue;
          if (IdValue->TryGetString(TmpValue)) { Id = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> NameValue = obj->TryGetField(TEXT("Name"));
      if (NameValue.IsValid() && !NameValue->IsNull())
      {
          FString TmpValue;
          if (NameValue->TryGetString(TmpValue)) { Name = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerSegmentsResult::~FGetPlayerSegmentsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayerSegmentsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Segments.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Segments"));
          for (const FGetSegmentResult& item : Segments)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerSegmentsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&SegmentsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Segments"));
      for (int32 Idx = 0; Idx < SegmentsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = SegmentsArray[Idx];
          Segments.Add(FGetSegmentResult(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FStatisticNameVersion::~FStatisticNameVersion()
  {
  
  }
  
  void PlayFab::ClientModels::FStatisticNameVersion::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName);
  
      writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(static_cast<int64>(Version));
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FStatisticNameVersion::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          uint32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerStatisticsRequest::~FGetPlayerStatisticsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayerStatisticsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (StatisticNames.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("StatisticNames"));
          for (const FString& item : StatisticNames)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (StatisticNameVersions.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("StatisticNameVersions"));
          for (const FStatisticNameVersion& item : StatisticNameVersions)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerStatisticsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      obj->TryGetStringArrayField(TEXT("StatisticNames"), StatisticNames);
  
      const TArray<TSharedPtr<FJsonValue>>&StatisticNameVersionsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("StatisticNameVersions"));
      for (int32 Idx = 0; Idx < StatisticNameVersionsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = StatisticNameVersionsArray[Idx];
          StatisticNameVersions.Add(FStatisticNameVersion(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerStatisticsResult::~FGetPlayerStatisticsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayerStatisticsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Statistics.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Statistics"));
          for (const FStatisticValue& item : Statistics)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerStatisticsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&StatisticsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Statistics"));
      for (int32 Idx = 0; Idx < StatisticsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = StatisticsArray[Idx];
          Statistics.Add(FStatisticValue(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerStatisticVersionsRequest::~FGetPlayerStatisticVersionsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayerStatisticVersionsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (StatisticName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerStatisticVersionsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FPlayerStatisticVersion::~FPlayerStatisticVersion()
  {
  
  }
  
  void PlayFab::ClientModels::FPlayerStatisticVersion::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("ActivationTime")); writeDatetime(ActivationTime, writer);
  
      if (DeactivationTime.notNull()) { writer->WriteIdentifierPrefix(TEXT("DeactivationTime")); writeDatetime(DeactivationTime, writer); }
  
      if (ScheduledActivationTime.notNull()) { writer->WriteIdentifierPrefix(TEXT("ScheduledActivationTime")); writeDatetime(ScheduledActivationTime, writer); }
  
      if (ScheduledDeactivationTime.notNull()) { writer->WriteIdentifierPrefix(TEXT("ScheduledDeactivationTime")); writeDatetime(ScheduledDeactivationTime, writer); }
  
      if (StatisticName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName); }
  
      writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(static_cast<int64>(Version));
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPlayerStatisticVersion::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ActivationTimeValue = obj->TryGetField(TEXT("ActivationTime"));
      if (ActivationTimeValue.IsValid())
          ActivationTime = readDatetime(ActivationTimeValue);
  
  
      const TSharedPtr<FJsonValue> DeactivationTimeValue = obj->TryGetField(TEXT("DeactivationTime"));
      if (DeactivationTimeValue.IsValid())
          DeactivationTime = readDatetime(DeactivationTimeValue);
  
  
      const TSharedPtr<FJsonValue> ScheduledActivationTimeValue = obj->TryGetField(TEXT("ScheduledActivationTime"));
      if (ScheduledActivationTimeValue.IsValid())
          ScheduledActivationTime = readDatetime(ScheduledActivationTimeValue);
  
  
      const TSharedPtr<FJsonValue> ScheduledDeactivationTimeValue = obj->TryGetField(TEXT("ScheduledDeactivationTime"));
      if (ScheduledDeactivationTimeValue.IsValid())
          ScheduledDeactivationTime = readDatetime(ScheduledDeactivationTimeValue);
  
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          uint32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerStatisticVersionsResult::~FGetPlayerStatisticVersionsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayerStatisticVersionsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (StatisticVersions.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("StatisticVersions"));
          for (const FPlayerStatisticVersion& item : StatisticVersions)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerStatisticVersionsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&StatisticVersionsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("StatisticVersions"));
      for (int32 Idx = 0; Idx < StatisticVersionsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = StatisticVersionsArray[Idx];
          StatisticVersions.Add(FPlayerStatisticVersion(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerTagsRequest::~FGetPlayerTagsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayerTagsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Namespace.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Namespace")); writer->WriteValue(Namespace); }
  
      writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerTagsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> NamespaceValue = obj->TryGetField(TEXT("Namespace"));
      if (NamespaceValue.IsValid() && !NamespaceValue->IsNull())
      {
          FString TmpValue;
          if (NamespaceValue->TryGetString(TmpValue)) { Namespace = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerTagsResult::~FGetPlayerTagsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayerTagsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId);
  
      writer->WriteArrayStart(TEXT("Tags"));
      for (const FString& item : Tags)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerTagsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("Tags"), Tags);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerTradesRequest::~FGetPlayerTradesRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayerTradesRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (StatusFilter.notNull()) { writer->WriteIdentifierPrefix(TEXT("StatusFilter")); writeTradeStatusEnumJSON(StatusFilter, writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerTradesRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      StatusFilter = readTradeStatusFromValue(obj->TryGetField(TEXT("StatusFilter")));
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayerTradesResponse::~FGetPlayerTradesResponse()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayerTradesResponse::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AcceptedTrades.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("AcceptedTrades"));
          for (const FTradeInfo& item : AcceptedTrades)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (OpenedTrades.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("OpenedTrades"));
          for (const FTradeInfo& item : OpenedTrades)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayerTradesResponse::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&AcceptedTradesArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("AcceptedTrades"));
      for (int32 Idx = 0; Idx < AcceptedTradesArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = AcceptedTradesArray[Idx];
          AcceptedTrades.Add(FTradeInfo(CurrentItem->AsObject()));
      }
  
  
      const TArray<TSharedPtr<FJsonValue>>&OpenedTradesArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("OpenedTrades"));
      for (int32 Idx = 0; Idx < OpenedTradesArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = OpenedTradesArray[Idx];
          OpenedTrades.Add(FTradeInfo(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromFacebookIDsRequest::~FGetPlayFabIDsFromFacebookIDsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromFacebookIDsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("FacebookIDs"));
      for (const FString& item : FacebookIDs)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromFacebookIDsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("FacebookIDs"), FacebookIDs);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromFacebookIDsResult::~FGetPlayFabIDsFromFacebookIDsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromFacebookIDsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Data"));
          for (const FFacebookPlayFabIdPair& item : Data)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromFacebookIDsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&DataArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Data"));
      for (int32 Idx = 0; Idx < DataArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = DataArray[Idx];
          Data.Add(FFacebookPlayFabIdPair(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromFacebookInstantGamesIdsRequest::~FGetPlayFabIDsFromFacebookInstantGamesIdsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromFacebookInstantGamesIdsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("FacebookInstantGamesIds"));
      for (const FString& item : FacebookInstantGamesIds)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromFacebookInstantGamesIdsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("FacebookInstantGamesIds"), FacebookInstantGamesIds);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromFacebookInstantGamesIdsResult::~FGetPlayFabIDsFromFacebookInstantGamesIdsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromFacebookInstantGamesIdsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Data"));
          for (const FFacebookInstantGamesPlayFabIdPair& item : Data)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromFacebookInstantGamesIdsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&DataArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Data"));
      for (int32 Idx = 0; Idx < DataArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = DataArray[Idx];
          Data.Add(FFacebookInstantGamesPlayFabIdPair(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromGameCenterIDsRequest::~FGetPlayFabIDsFromGameCenterIDsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromGameCenterIDsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("GameCenterIDs"));
      for (const FString& item : GameCenterIDs)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromGameCenterIDsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("GameCenterIDs"), GameCenterIDs);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromGameCenterIDsResult::~FGetPlayFabIDsFromGameCenterIDsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromGameCenterIDsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Data"));
          for (const FGameCenterPlayFabIdPair& item : Data)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromGameCenterIDsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&DataArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Data"));
      for (int32 Idx = 0; Idx < DataArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = DataArray[Idx];
          Data.Add(FGameCenterPlayFabIdPair(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromGenericIDsRequest::~FGetPlayFabIDsFromGenericIDsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromGenericIDsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("GenericIDs"));
      for (const FGenericServiceId& item : GenericIDs)
          item.writeJSON(writer);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromGenericIDsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&GenericIDsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("GenericIDs"));
      for (int32 Idx = 0; Idx < GenericIDsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = GenericIDsArray[Idx];
          GenericIDs.Add(FGenericServiceId(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromGenericIDsResult::~FGetPlayFabIDsFromGenericIDsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromGenericIDsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Data"));
          for (const FGenericPlayFabIdPair& item : Data)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromGenericIDsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&DataArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Data"));
      for (int32 Idx = 0; Idx < DataArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = DataArray[Idx];
          Data.Add(FGenericPlayFabIdPair(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromGoogleIDsRequest::~FGetPlayFabIDsFromGoogleIDsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromGoogleIDsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("GoogleIDs"));
      for (const FString& item : GoogleIDs)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromGoogleIDsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("GoogleIDs"), GoogleIDs);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGooglePlayFabIdPair::~FGooglePlayFabIdPair()
  {
  
  }
  
  void PlayFab::ClientModels::FGooglePlayFabIdPair::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (GoogleId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GoogleId")); writer->WriteValue(GoogleId); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGooglePlayFabIdPair::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> GoogleIdValue = obj->TryGetField(TEXT("GoogleId"));
      if (GoogleIdValue.IsValid() && !GoogleIdValue->IsNull())
      {
          FString TmpValue;
          if (GoogleIdValue->TryGetString(TmpValue)) { GoogleId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromGoogleIDsResult::~FGetPlayFabIDsFromGoogleIDsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromGoogleIDsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Data"));
          for (const FGooglePlayFabIdPair& item : Data)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromGoogleIDsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&DataArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Data"));
      for (int32 Idx = 0; Idx < DataArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = DataArray[Idx];
          Data.Add(FGooglePlayFabIdPair(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromKongregateIDsRequest::~FGetPlayFabIDsFromKongregateIDsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromKongregateIDsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("KongregateIDs"));
      for (const FString& item : KongregateIDs)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromKongregateIDsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("KongregateIDs"), KongregateIDs);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FKongregatePlayFabIdPair::~FKongregatePlayFabIdPair()
  {
  
  }
  
  void PlayFab::ClientModels::FKongregatePlayFabIdPair::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (KongregateId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("KongregateId")); writer->WriteValue(KongregateId); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FKongregatePlayFabIdPair::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> KongregateIdValue = obj->TryGetField(TEXT("KongregateId"));
      if (KongregateIdValue.IsValid() && !KongregateIdValue->IsNull())
      {
          FString TmpValue;
          if (KongregateIdValue->TryGetString(TmpValue)) { KongregateId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromKongregateIDsResult::~FGetPlayFabIDsFromKongregateIDsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromKongregateIDsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Data"));
          for (const FKongregatePlayFabIdPair& item : Data)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromKongregateIDsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&DataArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Data"));
      for (int32 Idx = 0; Idx < DataArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = DataArray[Idx];
          Data.Add(FKongregatePlayFabIdPair(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromNintendoSwitchDeviceIdsRequest::~FGetPlayFabIDsFromNintendoSwitchDeviceIdsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromNintendoSwitchDeviceIdsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("NintendoSwitchDeviceIds"));
      for (const FString& item : NintendoSwitchDeviceIds)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromNintendoSwitchDeviceIdsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("NintendoSwitchDeviceIds"), NintendoSwitchDeviceIds);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FNintendoSwitchPlayFabIdPair::~FNintendoSwitchPlayFabIdPair()
  {
  
  }
  
  void PlayFab::ClientModels::FNintendoSwitchPlayFabIdPair::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (NintendoSwitchDeviceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("NintendoSwitchDeviceId")); writer->WriteValue(NintendoSwitchDeviceId); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FNintendoSwitchPlayFabIdPair::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> NintendoSwitchDeviceIdValue = obj->TryGetField(TEXT("NintendoSwitchDeviceId"));
      if (NintendoSwitchDeviceIdValue.IsValid() && !NintendoSwitchDeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (NintendoSwitchDeviceIdValue->TryGetString(TmpValue)) { NintendoSwitchDeviceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromNintendoSwitchDeviceIdsResult::~FGetPlayFabIDsFromNintendoSwitchDeviceIdsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromNintendoSwitchDeviceIdsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Data"));
          for (const FNintendoSwitchPlayFabIdPair& item : Data)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromNintendoSwitchDeviceIdsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&DataArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Data"));
      for (int32 Idx = 0; Idx < DataArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = DataArray[Idx];
          Data.Add(FNintendoSwitchPlayFabIdPair(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromPSNAccountIDsRequest::~FGetPlayFabIDsFromPSNAccountIDsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromPSNAccountIDsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (IssuerId.notNull()) { writer->WriteIdentifierPrefix(TEXT("IssuerId")); writer->WriteValue(IssuerId); }
  
      writer->WriteArrayStart(TEXT("PSNAccountIDs"));
      for (const FString& item : PSNAccountIDs)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromPSNAccountIDsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> IssuerIdValue = obj->TryGetField(TEXT("IssuerId"));
      if (IssuerIdValue.IsValid() && !IssuerIdValue->IsNull())
      {
          int32 TmpValue;
          if (IssuerIdValue->TryGetNumber(TmpValue)) { IssuerId = TmpValue; }
      }
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("PSNAccountIDs"), PSNAccountIDs);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FPSNAccountPlayFabIdPair::~FPSNAccountPlayFabIdPair()
  {
  
  }
  
  void PlayFab::ClientModels::FPSNAccountPlayFabIdPair::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (PSNAccountId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PSNAccountId")); writer->WriteValue(PSNAccountId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPSNAccountPlayFabIdPair::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PSNAccountIdValue = obj->TryGetField(TEXT("PSNAccountId"));
      if (PSNAccountIdValue.IsValid() && !PSNAccountIdValue->IsNull())
      {
          FString TmpValue;
          if (PSNAccountIdValue->TryGetString(TmpValue)) { PSNAccountId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromPSNAccountIDsResult::~FGetPlayFabIDsFromPSNAccountIDsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromPSNAccountIDsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Data"));
          for (const FPSNAccountPlayFabIdPair& item : Data)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromPSNAccountIDsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&DataArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Data"));
      for (int32 Idx = 0; Idx < DataArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = DataArray[Idx];
          Data.Add(FPSNAccountPlayFabIdPair(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromSteamIDsRequest::~FGetPlayFabIDsFromSteamIDsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromSteamIDsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (SteamStringIDs.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("SteamStringIDs"));
          for (const FString& item : SteamStringIDs)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromSteamIDsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      obj->TryGetStringArrayField(TEXT("SteamStringIDs"), SteamStringIDs);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FSteamPlayFabIdPair::~FSteamPlayFabIdPair()
  {
  
  }
  
  void PlayFab::ClientModels::FSteamPlayFabIdPair::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (SteamStringId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SteamStringId")); writer->WriteValue(SteamStringId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FSteamPlayFabIdPair::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SteamStringIdValue = obj->TryGetField(TEXT("SteamStringId"));
      if (SteamStringIdValue.IsValid() && !SteamStringIdValue->IsNull())
      {
          FString TmpValue;
          if (SteamStringIdValue->TryGetString(TmpValue)) { SteamStringId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromSteamIDsResult::~FGetPlayFabIDsFromSteamIDsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromSteamIDsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Data"));
          for (const FSteamPlayFabIdPair& item : Data)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromSteamIDsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&DataArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Data"));
      for (int32 Idx = 0; Idx < DataArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = DataArray[Idx];
          Data.Add(FSteamPlayFabIdPair(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromTwitchIDsRequest::~FGetPlayFabIDsFromTwitchIDsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromTwitchIDsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("TwitchIds"));
      for (const FString& item : TwitchIds)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromTwitchIDsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("TwitchIds"), TwitchIds);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FTwitchPlayFabIdPair::~FTwitchPlayFabIdPair()
  {
  
  }
  
  void PlayFab::ClientModels::FTwitchPlayFabIdPair::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (TwitchId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TwitchId")); writer->WriteValue(TwitchId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FTwitchPlayFabIdPair::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TwitchIdValue = obj->TryGetField(TEXT("TwitchId"));
      if (TwitchIdValue.IsValid() && !TwitchIdValue->IsNull())
      {
          FString TmpValue;
          if (TwitchIdValue->TryGetString(TmpValue)) { TwitchId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromTwitchIDsResult::~FGetPlayFabIDsFromTwitchIDsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromTwitchIDsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Data"));
          for (const FTwitchPlayFabIdPair& item : Data)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromTwitchIDsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&DataArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Data"));
      for (int32 Idx = 0; Idx < DataArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = DataArray[Idx];
          Data.Add(FTwitchPlayFabIdPair(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromXboxLiveIDsRequest::~FGetPlayFabIDsFromXboxLiveIDsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromXboxLiveIDsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Sandbox.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Sandbox")); writer->WriteValue(Sandbox); }
  
      writer->WriteArrayStart(TEXT("XboxLiveAccountIDs"));
      for (const FString& item : XboxLiveAccountIDs)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromXboxLiveIDsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> SandboxValue = obj->TryGetField(TEXT("Sandbox"));
      if (SandboxValue.IsValid() && !SandboxValue->IsNull())
      {
          FString TmpValue;
          if (SandboxValue->TryGetString(TmpValue)) { Sandbox = TmpValue; }
      }
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("XboxLiveAccountIDs"), XboxLiveAccountIDs);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FXboxLiveAccountPlayFabIdPair::~FXboxLiveAccountPlayFabIdPair()
  {
  
  }
  
  void PlayFab::ClientModels::FXboxLiveAccountPlayFabIdPair::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (XboxLiveAccountId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("XboxLiveAccountId")); writer->WriteValue(XboxLiveAccountId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FXboxLiveAccountPlayFabIdPair::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> XboxLiveAccountIdValue = obj->TryGetField(TEXT("XboxLiveAccountId"));
      if (XboxLiveAccountIdValue.IsValid() && !XboxLiveAccountIdValue->IsNull())
      {
          FString TmpValue;
          if (XboxLiveAccountIdValue->TryGetString(TmpValue)) { XboxLiveAccountId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPlayFabIDsFromXboxLiveIDsResult::~FGetPlayFabIDsFromXboxLiveIDsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPlayFabIDsFromXboxLiveIDsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Data"));
          for (const FXboxLiveAccountPlayFabIdPair& item : Data)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPlayFabIDsFromXboxLiveIDsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&DataArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Data"));
      for (int32 Idx = 0; Idx < DataArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = DataArray[Idx];
          Data.Add(FXboxLiveAccountPlayFabIdPair(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPublisherDataRequest::~FGetPublisherDataRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPublisherDataRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("Keys"));
      for (const FString& item : Keys)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPublisherDataRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("Keys"), Keys);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPublisherDataResult::~FGetPublisherDataResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPublisherDataResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Data"));
          for (TMap<FString, FString>::TConstIterator It(Data); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPublisherDataResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* DataObject;
      if (obj->TryGetObjectField(TEXT("Data"), DataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*DataObject)->Values); It; ++It)
          {
              Data.Add(It.Key(), It.Value()->AsString());
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPurchaseRequest::~FGetPurchaseRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPurchaseRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("OrderId")); writer->WriteValue(OrderId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPurchaseRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> OrderIdValue = obj->TryGetField(TEXT("OrderId"));
      if (OrderIdValue.IsValid() && !OrderIdValue->IsNull())
      {
          FString TmpValue;
          if (OrderIdValue->TryGetString(TmpValue)) { OrderId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetPurchaseResult::~FGetPurchaseResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetPurchaseResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (OrderId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("OrderId")); writer->WriteValue(OrderId); }
  
      if (PaymentProvider.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PaymentProvider")); writer->WriteValue(PaymentProvider); }
  
      writer->WriteIdentifierPrefix(TEXT("PurchaseDate")); writeDatetime(PurchaseDate, writer);
  
      if (TransactionId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TransactionId")); writer->WriteValue(TransactionId); }
  
      if (TransactionStatus.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("TransactionStatus")); writer->WriteValue(TransactionStatus); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetPurchaseResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> OrderIdValue = obj->TryGetField(TEXT("OrderId"));
      if (OrderIdValue.IsValid() && !OrderIdValue->IsNull())
      {
          FString TmpValue;
          if (OrderIdValue->TryGetString(TmpValue)) { OrderId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PaymentProviderValue = obj->TryGetField(TEXT("PaymentProvider"));
      if (PaymentProviderValue.IsValid() && !PaymentProviderValue->IsNull())
      {
          FString TmpValue;
          if (PaymentProviderValue->TryGetString(TmpValue)) { PaymentProvider = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PurchaseDateValue = obj->TryGetField(TEXT("PurchaseDate"));
      if (PurchaseDateValue.IsValid())
          PurchaseDate = readDatetime(PurchaseDateValue);
  
  
      const TSharedPtr<FJsonValue> TransactionIdValue = obj->TryGetField(TEXT("TransactionId"));
      if (TransactionIdValue.IsValid() && !TransactionIdValue->IsNull())
      {
          FString TmpValue;
          if (TransactionIdValue->TryGetString(TmpValue)) { TransactionId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TransactionStatusValue = obj->TryGetField(TEXT("TransactionStatus"));
      if (TransactionStatusValue.IsValid() && !TransactionStatusValue->IsNull())
      {
          FString TmpValue;
          if (TransactionStatusValue->TryGetString(TmpValue)) { TransactionStatus = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetSharedGroupDataRequest::~FGetSharedGroupDataRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetSharedGroupDataRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (GetMembers.notNull()) { writer->WriteIdentifierPrefix(TEXT("GetMembers")); writer->WriteValue(GetMembers); }
  
      if (Keys.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Keys"));
          for (const FString& item : Keys)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteIdentifierPrefix(TEXT("SharedGroupId")); writer->WriteValue(SharedGroupId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetSharedGroupDataRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> GetMembersValue = obj->TryGetField(TEXT("GetMembers"));
      if (GetMembersValue.IsValid() && !GetMembersValue->IsNull())
      {
          bool TmpValue;
          if (GetMembersValue->TryGetBool(TmpValue)) { GetMembers = TmpValue; }
      }
  
      obj->TryGetStringArrayField(TEXT("Keys"), Keys);
  
      const TSharedPtr<FJsonValue> SharedGroupIdValue = obj->TryGetField(TEXT("SharedGroupId"));
      if (SharedGroupIdValue.IsValid() && !SharedGroupIdValue->IsNull())
      {
          FString TmpValue;
          if (SharedGroupIdValue->TryGetString(TmpValue)) { SharedGroupId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FSharedGroupDataRecord::~FSharedGroupDataRecord()
  {
  
  }
  
  void PlayFab::ClientModels::FSharedGroupDataRecord::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("LastUpdated")); writeDatetime(LastUpdated, writer);
  
      if (LastUpdatedBy.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("LastUpdatedBy")); writer->WriteValue(LastUpdatedBy); }
  
      if (Permission.notNull()) { writer->WriteIdentifierPrefix(TEXT("Permission")); writeUserDataPermissionEnumJSON(Permission, writer); }
  
      if (Value.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Value")); writer->WriteValue(Value); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FSharedGroupDataRecord::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> LastUpdatedValue = obj->TryGetField(TEXT("LastUpdated"));
      if (LastUpdatedValue.IsValid())
          LastUpdated = readDatetime(LastUpdatedValue);
  
  
      const TSharedPtr<FJsonValue> LastUpdatedByValue = obj->TryGetField(TEXT("LastUpdatedBy"));
      if (LastUpdatedByValue.IsValid() && !LastUpdatedByValue->IsNull())
      {
          FString TmpValue;
          if (LastUpdatedByValue->TryGetString(TmpValue)) { LastUpdatedBy = TmpValue; }
      }
  
      Permission = readUserDataPermissionFromValue(obj->TryGetField(TEXT("Permission")));
  
      const TSharedPtr<FJsonValue> ValueValue = obj->TryGetField(TEXT("Value"));
      if (ValueValue.IsValid() && !ValueValue->IsNull())
      {
          FString TmpValue;
          if (ValueValue->TryGetString(TmpValue)) { Value = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetSharedGroupDataResult::~FGetSharedGroupDataResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetSharedGroupDataResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Data"));
          for (TMap<FString, FSharedGroupDataRecord>::TConstIterator It(Data); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      if (Members.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Members"));
          for (const FString& item : Members)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetSharedGroupDataResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* DataObject;
      if (obj->TryGetObjectField(TEXT("Data"), DataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*DataObject)->Values); It; ++It)
          {
              Data.Add(It.Key(), FSharedGroupDataRecord(It.Value()->AsObject()));
          }
      }
  
      obj->TryGetStringArrayField(TEXT("Members"), Members);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetStoreItemsRequest::~FGetStoreItemsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetStoreItemsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      writer->WriteIdentifierPrefix(TEXT("StoreId")); writer->WriteValue(StoreId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetStoreItemsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StoreIdValue = obj->TryGetField(TEXT("StoreId"));
      if (StoreIdValue.IsValid() && !StoreIdValue->IsNull())
      {
          FString TmpValue;
          if (StoreIdValue->TryGetString(TmpValue)) { StoreId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FStoreMarketingModel::~FStoreMarketingModel()
  {
  
  }
  
  void PlayFab::ClientModels::FStoreMarketingModel::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Description.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Description")); writer->WriteValue(Description); }
  
      if (DisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DisplayName")); writer->WriteValue(DisplayName); }
  
      if (Metadata.notNull()) { writer->WriteIdentifierPrefix(TEXT("Metadata")); Metadata.writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FStoreMarketingModel::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DescriptionValue = obj->TryGetField(TEXT("Description"));
      if (DescriptionValue.IsValid() && !DescriptionValue->IsNull())
      {
          FString TmpValue;
          if (DescriptionValue->TryGetString(TmpValue)) { Description = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> DisplayNameValue = obj->TryGetField(TEXT("DisplayName"));
      if (DisplayNameValue.IsValid() && !DisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (DisplayNameValue->TryGetString(TmpValue)) { DisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> MetadataValue = obj->TryGetField(TEXT("Metadata"));
      if (MetadataValue.IsValid() && !MetadataValue->IsNull())
      {
          Metadata = FJsonKeeper(MetadataValue);
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeSourceTypeEnumJSON(SourceType enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case SourceTypeAdmin: writer->WriteValue(TEXT("Admin")); break;
      case SourceTypeBackEnd: writer->WriteValue(TEXT("BackEnd")); break;
      case SourceTypeGameClient: writer->WriteValue(TEXT("GameClient")); break;
      case SourceTypeGameServer: writer->WriteValue(TEXT("GameServer")); break;
      case SourceTypePartner: writer->WriteValue(TEXT("Partner")); break;
      case SourceTypeCustom: writer->WriteValue(TEXT("Custom")); break;
      case SourceTypeAPI: writer->WriteValue(TEXT("API")); break;
      }
  }
  
  ClientModels::SourceType PlayFab::ClientModels::readSourceTypeFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readSourceTypeFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::SourceType PlayFab::ClientModels::readSourceTypeFromValue(const FString& value)
  {
      static TMap<FString, SourceType> _SourceTypeMap;
      if (_SourceTypeMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _SourceTypeMap.Add(TEXT("Admin"), SourceTypeAdmin);
          _SourceTypeMap.Add(TEXT("BackEnd"), SourceTypeBackEnd);
          _SourceTypeMap.Add(TEXT("GameClient"), SourceTypeGameClient);
          _SourceTypeMap.Add(TEXT("GameServer"), SourceTypeGameServer);
          _SourceTypeMap.Add(TEXT("Partner"), SourceTypePartner);
          _SourceTypeMap.Add(TEXT("Custom"), SourceTypeCustom);
          _SourceTypeMap.Add(TEXT("API"), SourceTypeAPI);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _SourceTypeMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return SourceTypeAdmin; // Basically critical fail
  }
  
  PlayFab::ClientModels::FStoreItem::~FStoreItem()
  {
  
  }
  
  void PlayFab::ClientModels::FStoreItem::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CustomData.notNull()) { writer->WriteIdentifierPrefix(TEXT("CustomData")); CustomData.writeJSON(writer); }
  
      if (DisplayPosition.notNull()) { writer->WriteIdentifierPrefix(TEXT("DisplayPosition")); writer->WriteValue(static_cast<int64>(DisplayPosition)); }
  
      writer->WriteIdentifierPrefix(TEXT("ItemId")); writer->WriteValue(ItemId);
  
      if (RealCurrencyPrices.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("RealCurrencyPrices"));
          for (TMap<FString, uint32>::TConstIterator It(RealCurrencyPrices); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue(static_cast<int64>((*It).Value));
          }
          writer->WriteObjectEnd();
      }
  
      if (VirtualCurrencyPrices.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VirtualCurrencyPrices"));
          for (TMap<FString, uint32>::TConstIterator It(VirtualCurrencyPrices); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue(static_cast<int64>((*It).Value));
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FStoreItem::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CustomDataValue = obj->TryGetField(TEXT("CustomData"));
      if (CustomDataValue.IsValid() && !CustomDataValue->IsNull())
      {
          CustomData = FJsonKeeper(CustomDataValue);
      }
  
      const TSharedPtr<FJsonValue> DisplayPositionValue = obj->TryGetField(TEXT("DisplayPosition"));
      if (DisplayPositionValue.IsValid() && !DisplayPositionValue->IsNull())
      {
          uint32 TmpValue;
          if (DisplayPositionValue->TryGetNumber(TmpValue)) { DisplayPosition = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemIdValue = obj->TryGetField(TEXT("ItemId"));
      if (ItemIdValue.IsValid() && !ItemIdValue->IsNull())
      {
          FString TmpValue;
          if (ItemIdValue->TryGetString(TmpValue)) { ItemId = TmpValue; }
      }
  
      const TSharedPtr<FJsonObject>* RealCurrencyPricesObject;
      if (obj->TryGetObjectField(TEXT("RealCurrencyPrices"), RealCurrencyPricesObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*RealCurrencyPricesObject)->Values); It; ++It)
          {
              uint32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              RealCurrencyPrices.Add(It.Key(), TmpValue);
          }
      }
  
      const TSharedPtr<FJsonObject>* VirtualCurrencyPricesObject;
      if (obj->TryGetObjectField(TEXT("VirtualCurrencyPrices"), VirtualCurrencyPricesObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VirtualCurrencyPricesObject)->Values); It; ++It)
          {
              uint32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              VirtualCurrencyPrices.Add(It.Key(), TmpValue);
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetStoreItemsResult::~FGetStoreItemsResult()
  {
      //if (MarketingData != nullptr) delete MarketingData;
  
  }
  
  void PlayFab::ClientModels::FGetStoreItemsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      if (MarketingData.IsValid()) { writer->WriteIdentifierPrefix(TEXT("MarketingData")); MarketingData->writeJSON(writer); }
  
      if (Source.notNull()) { writer->WriteIdentifierPrefix(TEXT("Source")); writeSourceTypeEnumJSON(Source, writer); }
  
      if (Store.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Store"));
          for (const FStoreItem& item : Store)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (StoreId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("StoreId")); writer->WriteValue(StoreId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetStoreItemsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> MarketingDataValue = obj->TryGetField(TEXT("MarketingData"));
      if (MarketingDataValue.IsValid() && !MarketingDataValue->IsNull())
      {
          MarketingData = MakeShareable(new FStoreMarketingModel(MarketingDataValue->AsObject()));
      }
  
      Source = readSourceTypeFromValue(obj->TryGetField(TEXT("Source")));
  
      const TArray<TSharedPtr<FJsonValue>>&StoreArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Store"));
      for (int32 Idx = 0; Idx < StoreArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = StoreArray[Idx];
          Store.Add(FStoreItem(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> StoreIdValue = obj->TryGetField(TEXT("StoreId"));
      if (StoreIdValue.IsValid() && !StoreIdValue->IsNull())
      {
          FString TmpValue;
          if (StoreIdValue->TryGetString(TmpValue)) { StoreId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetTimeRequest::~FGetTimeRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetTimeRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetTimeRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetTimeResult::~FGetTimeResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetTimeResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Time")); writeDatetime(Time, writer);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetTimeResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> TimeValue = obj->TryGetField(TEXT("Time"));
      if (TimeValue.IsValid())
          Time = readDatetime(TimeValue);
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetTitleDataRequest::~FGetTitleDataRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetTitleDataRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Keys.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Keys"));
          for (const FString& item : Keys)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetTitleDataRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      obj->TryGetStringArrayField(TEXT("Keys"), Keys);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetTitleDataResult::~FGetTitleDataResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetTitleDataResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Data"));
          for (TMap<FString, FString>::TConstIterator It(Data); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetTitleDataResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* DataObject;
      if (obj->TryGetObjectField(TEXT("Data"), DataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*DataObject)->Values); It; ++It)
          {
              Data.Add(It.Key(), It.Value()->AsString());
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetTitleNewsRequest::~FGetTitleNewsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetTitleNewsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Count.notNull()) { writer->WriteIdentifierPrefix(TEXT("Count")); writer->WriteValue(Count); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetTitleNewsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CountValue = obj->TryGetField(TEXT("Count"));
      if (CountValue.IsValid() && !CountValue->IsNull())
      {
          int32 TmpValue;
          if (CountValue->TryGetNumber(TmpValue)) { Count = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FTitleNewsItem::~FTitleNewsItem()
  {
  
  }
  
  void PlayFab::ClientModels::FTitleNewsItem::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Body.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Body")); writer->WriteValue(Body); }
  
      if (NewsId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("NewsId")); writer->WriteValue(NewsId); }
  
      writer->WriteIdentifierPrefix(TEXT("Timestamp")); writeDatetime(Timestamp, writer);
  
      if (Title.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Title")); writer->WriteValue(Title); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FTitleNewsItem::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> BodyValue = obj->TryGetField(TEXT("Body"));
      if (BodyValue.IsValid() && !BodyValue->IsNull())
      {
          FString TmpValue;
          if (BodyValue->TryGetString(TmpValue)) { Body = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> NewsIdValue = obj->TryGetField(TEXT("NewsId"));
      if (NewsIdValue.IsValid() && !NewsIdValue->IsNull())
      {
          FString TmpValue;
          if (NewsIdValue->TryGetString(TmpValue)) { NewsId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TimestampValue = obj->TryGetField(TEXT("Timestamp"));
      if (TimestampValue.IsValid())
          Timestamp = readDatetime(TimestampValue);
  
  
      const TSharedPtr<FJsonValue> TitleValue = obj->TryGetField(TEXT("Title"));
      if (TitleValue.IsValid() && !TitleValue->IsNull())
      {
          FString TmpValue;
          if (TitleValue->TryGetString(TmpValue)) { Title = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetTitleNewsResult::~FGetTitleNewsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetTitleNewsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (News.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("News"));
          for (const FTitleNewsItem& item : News)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetTitleNewsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&NewsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("News"));
      for (int32 Idx = 0; Idx < NewsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = NewsArray[Idx];
          News.Add(FTitleNewsItem(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetTitlePublicKeyRequest::~FGetTitlePublicKeyRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetTitlePublicKeyRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteIdentifierPrefix(TEXT("TitleSharedSecret")); writer->WriteValue(TitleSharedSecret);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetTitlePublicKeyRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleSharedSecretValue = obj->TryGetField(TEXT("TitleSharedSecret"));
      if (TitleSharedSecretValue.IsValid() && !TitleSharedSecretValue->IsNull())
      {
          FString TmpValue;
          if (TitleSharedSecretValue->TryGetString(TmpValue)) { TitleSharedSecret = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetTitlePublicKeyResult::~FGetTitlePublicKeyResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetTitlePublicKeyResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (RSAPublicKey.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("RSAPublicKey")); writer->WriteValue(RSAPublicKey); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetTitlePublicKeyResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> RSAPublicKeyValue = obj->TryGetField(TEXT("RSAPublicKey"));
      if (RSAPublicKeyValue.IsValid() && !RSAPublicKeyValue->IsNull())
      {
          FString TmpValue;
          if (RSAPublicKeyValue->TryGetString(TmpValue)) { RSAPublicKey = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetTradeStatusRequest::~FGetTradeStatusRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetTradeStatusRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("OfferingPlayerId")); writer->WriteValue(OfferingPlayerId);
  
      writer->WriteIdentifierPrefix(TEXT("TradeId")); writer->WriteValue(TradeId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetTradeStatusRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> OfferingPlayerIdValue = obj->TryGetField(TEXT("OfferingPlayerId"));
      if (OfferingPlayerIdValue.IsValid() && !OfferingPlayerIdValue->IsNull())
      {
          FString TmpValue;
          if (OfferingPlayerIdValue->TryGetString(TmpValue)) { OfferingPlayerId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TradeIdValue = obj->TryGetField(TEXT("TradeId"));
      if (TradeIdValue.IsValid() && !TradeIdValue->IsNull())
      {
          FString TmpValue;
          if (TradeIdValue->TryGetString(TmpValue)) { TradeId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetTradeStatusResponse::~FGetTradeStatusResponse()
  {
      //if (Trade != nullptr) delete Trade;
  
  }
  
  void PlayFab::ClientModels::FGetTradeStatusResponse::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Trade.IsValid()) { writer->WriteIdentifierPrefix(TEXT("Trade")); Trade->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetTradeStatusResponse::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> TradeValue = obj->TryGetField(TEXT("Trade"));
      if (TradeValue.IsValid() && !TradeValue->IsNull())
      {
          Trade = MakeShareable(new FTradeInfo(TradeValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetUserDataRequest::~FGetUserDataRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetUserDataRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (IfChangedFromDataVersion.notNull()) { writer->WriteIdentifierPrefix(TEXT("IfChangedFromDataVersion")); writer->WriteValue(static_cast<int64>(IfChangedFromDataVersion)); }
  
      if (Keys.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Keys"));
          for (const FString& item : Keys)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetUserDataRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> IfChangedFromDataVersionValue = obj->TryGetField(TEXT("IfChangedFromDataVersion"));
      if (IfChangedFromDataVersionValue.IsValid() && !IfChangedFromDataVersionValue->IsNull())
      {
          uint32 TmpValue;
          if (IfChangedFromDataVersionValue->TryGetNumber(TmpValue)) { IfChangedFromDataVersion = TmpValue; }
      }
  
      obj->TryGetStringArrayField(TEXT("Keys"), Keys);
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetUserDataResult::~FGetUserDataResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetUserDataResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Data"));
          for (TMap<FString, FUserDataRecord>::TConstIterator It(Data); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteIdentifierPrefix(TEXT("DataVersion")); writer->WriteValue(static_cast<int64>(DataVersion));
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetUserDataResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* DataObject;
      if (obj->TryGetObjectField(TEXT("Data"), DataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*DataObject)->Values); It; ++It)
          {
              Data.Add(It.Key(), FUserDataRecord(It.Value()->AsObject()));
          }
      }
  
      const TSharedPtr<FJsonValue> DataVersionValue = obj->TryGetField(TEXT("DataVersion"));
      if (DataVersionValue.IsValid() && !DataVersionValue->IsNull())
      {
          uint32 TmpValue;
          if (DataVersionValue->TryGetNumber(TmpValue)) { DataVersion = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetUserInventoryRequest::~FGetUserInventoryRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetUserInventoryRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetUserInventoryRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetUserInventoryResult::~FGetUserInventoryResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGetUserInventoryResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Inventory.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Inventory"));
          for (const FItemInstance& item : Inventory)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (VirtualCurrency.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VirtualCurrency"));
          for (TMap<FString, int32>::TConstIterator It(VirtualCurrency); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      if (VirtualCurrencyRechargeTimes.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VirtualCurrencyRechargeTimes"));
          for (TMap<FString, FVirtualCurrencyRechargeTime>::TConstIterator It(VirtualCurrencyRechargeTimes); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetUserInventoryResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&InventoryArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Inventory"));
      for (int32 Idx = 0; Idx < InventoryArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = InventoryArray[Idx];
          Inventory.Add(FItemInstance(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonObject>* VirtualCurrencyObject;
      if (obj->TryGetObjectField(TEXT("VirtualCurrency"), VirtualCurrencyObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VirtualCurrencyObject)->Values); It; ++It)
          {
              int32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              VirtualCurrency.Add(It.Key(), TmpValue);
          }
      }
  
      const TSharedPtr<FJsonObject>* VirtualCurrencyRechargeTimesObject;
      if (obj->TryGetObjectField(TEXT("VirtualCurrencyRechargeTimes"), VirtualCurrencyRechargeTimesObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VirtualCurrencyRechargeTimesObject)->Values); It; ++It)
          {
              VirtualCurrencyRechargeTimes.Add(It.Key(), FVirtualCurrencyRechargeTime(It.Value()->AsObject()));
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetWindowsHelloChallengeRequest::~FGetWindowsHelloChallengeRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGetWindowsHelloChallengeRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("PublicKeyHint")); writer->WriteValue(PublicKeyHint);
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetWindowsHelloChallengeRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PublicKeyHintValue = obj->TryGetField(TEXT("PublicKeyHint"));
      if (PublicKeyHintValue.IsValid() && !PublicKeyHintValue->IsNull())
      {
          FString TmpValue;
          if (PublicKeyHintValue->TryGetString(TmpValue)) { PublicKeyHint = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGetWindowsHelloChallengeResponse::~FGetWindowsHelloChallengeResponse()
  {
  
  }
  
  void PlayFab::ClientModels::FGetWindowsHelloChallengeResponse::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Challenge.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Challenge")); writer->WriteValue(Challenge); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGetWindowsHelloChallengeResponse::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ChallengeValue = obj->TryGetField(TEXT("Challenge"));
      if (ChallengeValue.IsValid() && !ChallengeValue->IsNull())
      {
          FString TmpValue;
          if (ChallengeValue->TryGetString(TmpValue)) { Challenge = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGrantCharacterToUserRequest::~FGrantCharacterToUserRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FGrantCharacterToUserRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      writer->WriteIdentifierPrefix(TEXT("CharacterName")); writer->WriteValue(CharacterName);
  
      writer->WriteIdentifierPrefix(TEXT("ItemId")); writer->WriteValue(ItemId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGrantCharacterToUserRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterNameValue = obj->TryGetField(TEXT("CharacterName"));
      if (CharacterNameValue.IsValid() && !CharacterNameValue->IsNull())
      {
          FString TmpValue;
          if (CharacterNameValue->TryGetString(TmpValue)) { CharacterName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemIdValue = obj->TryGetField(TEXT("ItemId"));
      if (ItemIdValue.IsValid() && !ItemIdValue->IsNull())
      {
          FString TmpValue;
          if (ItemIdValue->TryGetString(TmpValue)) { ItemId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FGrantCharacterToUserResult::~FGrantCharacterToUserResult()
  {
  
  }
  
  void PlayFab::ClientModels::FGrantCharacterToUserResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      if (CharacterType.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterType")); writer->WriteValue(CharacterType); }
  
      writer->WriteIdentifierPrefix(TEXT("Result")); writer->WriteValue(Result);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FGrantCharacterToUserResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterTypeValue = obj->TryGetField(TEXT("CharacterType"));
      if (CharacterTypeValue.IsValid() && !CharacterTypeValue->IsNull())
      {
          FString TmpValue;
          if (CharacterTypeValue->TryGetString(TmpValue)) { CharacterType = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ResultValue = obj->TryGetField(TEXT("Result"));
      if (ResultValue.IsValid() && !ResultValue->IsNull())
      {
          bool TmpValue;
          if (ResultValue->TryGetBool(TmpValue)) { Result = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FItemPurchaseRequest::~FItemPurchaseRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FItemPurchaseRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Annotation.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Annotation")); writer->WriteValue(Annotation); }
  
      writer->WriteIdentifierPrefix(TEXT("ItemId")); writer->WriteValue(ItemId);
  
      writer->WriteIdentifierPrefix(TEXT("Quantity")); writer->WriteValue(static_cast<int64>(Quantity));
  
      if (UpgradeFromItems.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("UpgradeFromItems"));
          for (const FString& item : UpgradeFromItems)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FItemPurchaseRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AnnotationValue = obj->TryGetField(TEXT("Annotation"));
      if (AnnotationValue.IsValid() && !AnnotationValue->IsNull())
      {
          FString TmpValue;
          if (AnnotationValue->TryGetString(TmpValue)) { Annotation = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemIdValue = obj->TryGetField(TEXT("ItemId"));
      if (ItemIdValue.IsValid() && !ItemIdValue->IsNull())
      {
          FString TmpValue;
          if (ItemIdValue->TryGetString(TmpValue)) { ItemId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> QuantityValue = obj->TryGetField(TEXT("Quantity"));
      if (QuantityValue.IsValid() && !QuantityValue->IsNull())
      {
          uint32 TmpValue;
          if (QuantityValue->TryGetNumber(TmpValue)) { Quantity = TmpValue; }
      }
  
      obj->TryGetStringArrayField(TEXT("UpgradeFromItems"), UpgradeFromItems);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkAndroidDeviceIDRequest::~FLinkAndroidDeviceIDRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkAndroidDeviceIDRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AndroidDevice.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AndroidDevice")); writer->WriteValue(AndroidDevice); }
  
      writer->WriteIdentifierPrefix(TEXT("AndroidDeviceId")); writer->WriteValue(AndroidDeviceId);
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      if (OS.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("OS")); writer->WriteValue(OS); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkAndroidDeviceIDRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AndroidDeviceValue = obj->TryGetField(TEXT("AndroidDevice"));
      if (AndroidDeviceValue.IsValid() && !AndroidDeviceValue->IsNull())
      {
          FString TmpValue;
          if (AndroidDeviceValue->TryGetString(TmpValue)) { AndroidDevice = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> AndroidDeviceIdValue = obj->TryGetField(TEXT("AndroidDeviceId"));
      if (AndroidDeviceIdValue.IsValid() && !AndroidDeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (AndroidDeviceIdValue->TryGetString(TmpValue)) { AndroidDeviceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> OSValue = obj->TryGetField(TEXT("OS"));
      if (OSValue.IsValid() && !OSValue->IsNull())
      {
          FString TmpValue;
          if (OSValue->TryGetString(TmpValue)) { OS = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkAndroidDeviceIDResult::~FLinkAndroidDeviceIDResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkAndroidDeviceIDResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkAndroidDeviceIDResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkCustomIDRequest::~FLinkCustomIDRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkCustomIDRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("CustomId")); writer->WriteValue(CustomId);
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkCustomIDRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CustomIdValue = obj->TryGetField(TEXT("CustomId"));
      if (CustomIdValue.IsValid() && !CustomIdValue->IsNull())
      {
          FString TmpValue;
          if (CustomIdValue->TryGetString(TmpValue)) { CustomId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkCustomIDResult::~FLinkCustomIDResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkCustomIDResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkCustomIDResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkFacebookAccountRequest::~FLinkFacebookAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkFacebookAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("AccessToken")); writer->WriteValue(AccessToken);
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkFacebookAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AccessTokenValue = obj->TryGetField(TEXT("AccessToken"));
      if (AccessTokenValue.IsValid() && !AccessTokenValue->IsNull())
      {
          FString TmpValue;
          if (AccessTokenValue->TryGetString(TmpValue)) { AccessToken = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkFacebookAccountResult::~FLinkFacebookAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkFacebookAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkFacebookAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkFacebookInstantGamesIdRequest::~FLinkFacebookInstantGamesIdRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkFacebookInstantGamesIdRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("FacebookInstantGamesSignature")); writer->WriteValue(FacebookInstantGamesSignature);
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkFacebookInstantGamesIdRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> FacebookInstantGamesSignatureValue = obj->TryGetField(TEXT("FacebookInstantGamesSignature"));
      if (FacebookInstantGamesSignatureValue.IsValid() && !FacebookInstantGamesSignatureValue->IsNull())
      {
          FString TmpValue;
          if (FacebookInstantGamesSignatureValue->TryGetString(TmpValue)) { FacebookInstantGamesSignature = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkFacebookInstantGamesIdResult::~FLinkFacebookInstantGamesIdResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkFacebookInstantGamesIdResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkFacebookInstantGamesIdResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkGameCenterAccountRequest::~FLinkGameCenterAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkGameCenterAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      writer->WriteIdentifierPrefix(TEXT("GameCenterId")); writer->WriteValue(GameCenterId);
  
      if (PublicKeyUrl.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PublicKeyUrl")); writer->WriteValue(PublicKeyUrl); }
  
      if (Salt.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Salt")); writer->WriteValue(Salt); }
  
      if (Signature.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Signature")); writer->WriteValue(Signature); }
  
      if (Timestamp.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Timestamp")); writer->WriteValue(Timestamp); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkGameCenterAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GameCenterIdValue = obj->TryGetField(TEXT("GameCenterId"));
      if (GameCenterIdValue.IsValid() && !GameCenterIdValue->IsNull())
      {
          FString TmpValue;
          if (GameCenterIdValue->TryGetString(TmpValue)) { GameCenterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PublicKeyUrlValue = obj->TryGetField(TEXT("PublicKeyUrl"));
      if (PublicKeyUrlValue.IsValid() && !PublicKeyUrlValue->IsNull())
      {
          FString TmpValue;
          if (PublicKeyUrlValue->TryGetString(TmpValue)) { PublicKeyUrl = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SaltValue = obj->TryGetField(TEXT("Salt"));
      if (SaltValue.IsValid() && !SaltValue->IsNull())
      {
          FString TmpValue;
          if (SaltValue->TryGetString(TmpValue)) { Salt = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SignatureValue = obj->TryGetField(TEXT("Signature"));
      if (SignatureValue.IsValid() && !SignatureValue->IsNull())
      {
          FString TmpValue;
          if (SignatureValue->TryGetString(TmpValue)) { Signature = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TimestampValue = obj->TryGetField(TEXT("Timestamp"));
      if (TimestampValue.IsValid() && !TimestampValue->IsNull())
      {
          FString TmpValue;
          if (TimestampValue->TryGetString(TmpValue)) { Timestamp = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkGameCenterAccountResult::~FLinkGameCenterAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkGameCenterAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkGameCenterAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkGoogleAccountRequest::~FLinkGoogleAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkGoogleAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      if (ServerAuthCode.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ServerAuthCode")); writer->WriteValue(ServerAuthCode); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkGoogleAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerAuthCodeValue = obj->TryGetField(TEXT("ServerAuthCode"));
      if (ServerAuthCodeValue.IsValid() && !ServerAuthCodeValue->IsNull())
      {
          FString TmpValue;
          if (ServerAuthCodeValue->TryGetString(TmpValue)) { ServerAuthCode = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkGoogleAccountResult::~FLinkGoogleAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkGoogleAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkGoogleAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkIOSDeviceIDRequest::~FLinkIOSDeviceIDRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkIOSDeviceIDRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("DeviceId")); writer->WriteValue(DeviceId);
  
      if (DeviceModel.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DeviceModel")); writer->WriteValue(DeviceModel); }
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      if (OS.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("OS")); writer->WriteValue(OS); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkIOSDeviceIDRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DeviceIdValue = obj->TryGetField(TEXT("DeviceId"));
      if (DeviceIdValue.IsValid() && !DeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (DeviceIdValue->TryGetString(TmpValue)) { DeviceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> DeviceModelValue = obj->TryGetField(TEXT("DeviceModel"));
      if (DeviceModelValue.IsValid() && !DeviceModelValue->IsNull())
      {
          FString TmpValue;
          if (DeviceModelValue->TryGetString(TmpValue)) { DeviceModel = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> OSValue = obj->TryGetField(TEXT("OS"));
      if (OSValue.IsValid() && !OSValue->IsNull())
      {
          FString TmpValue;
          if (OSValue->TryGetString(TmpValue)) { OS = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkIOSDeviceIDResult::~FLinkIOSDeviceIDResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkIOSDeviceIDResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkIOSDeviceIDResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkKongregateAccountRequest::~FLinkKongregateAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkKongregateAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("AuthTicket")); writer->WriteValue(AuthTicket);
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      writer->WriteIdentifierPrefix(TEXT("KongregateId")); writer->WriteValue(KongregateId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkKongregateAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AuthTicketValue = obj->TryGetField(TEXT("AuthTicket"));
      if (AuthTicketValue.IsValid() && !AuthTicketValue->IsNull())
      {
          FString TmpValue;
          if (AuthTicketValue->TryGetString(TmpValue)) { AuthTicket = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> KongregateIdValue = obj->TryGetField(TEXT("KongregateId"));
      if (KongregateIdValue.IsValid() && !KongregateIdValue->IsNull())
      {
          FString TmpValue;
          if (KongregateIdValue->TryGetString(TmpValue)) { KongregateId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkKongregateAccountResult::~FLinkKongregateAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkKongregateAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkKongregateAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkNintendoSwitchDeviceIdRequest::~FLinkNintendoSwitchDeviceIdRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkNintendoSwitchDeviceIdRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      writer->WriteIdentifierPrefix(TEXT("NintendoSwitchDeviceId")); writer->WriteValue(NintendoSwitchDeviceId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkNintendoSwitchDeviceIdRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> NintendoSwitchDeviceIdValue = obj->TryGetField(TEXT("NintendoSwitchDeviceId"));
      if (NintendoSwitchDeviceIdValue.IsValid() && !NintendoSwitchDeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (NintendoSwitchDeviceIdValue->TryGetString(TmpValue)) { NintendoSwitchDeviceId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkNintendoSwitchDeviceIdResult::~FLinkNintendoSwitchDeviceIdResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkNintendoSwitchDeviceIdResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkNintendoSwitchDeviceIdResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkOpenIdConnectRequest::~FLinkOpenIdConnectRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkOpenIdConnectRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("ConnectionId")); writer->WriteValue(ConnectionId);
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      writer->WriteIdentifierPrefix(TEXT("IdToken")); writer->WriteValue(IdToken);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkOpenIdConnectRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ConnectionIdValue = obj->TryGetField(TEXT("ConnectionId"));
      if (ConnectionIdValue.IsValid() && !ConnectionIdValue->IsNull())
      {
          FString TmpValue;
          if (ConnectionIdValue->TryGetString(TmpValue)) { ConnectionId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IdTokenValue = obj->TryGetField(TEXT("IdToken"));
      if (IdTokenValue.IsValid() && !IdTokenValue->IsNull())
      {
          FString TmpValue;
          if (IdTokenValue->TryGetString(TmpValue)) { IdToken = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkPSNAccountRequest::~FLinkPSNAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkPSNAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("AuthCode")); writer->WriteValue(AuthCode);
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      if (IssuerId.notNull()) { writer->WriteIdentifierPrefix(TEXT("IssuerId")); writer->WriteValue(IssuerId); }
  
      writer->WriteIdentifierPrefix(TEXT("RedirectUri")); writer->WriteValue(RedirectUri);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkPSNAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AuthCodeValue = obj->TryGetField(TEXT("AuthCode"));
      if (AuthCodeValue.IsValid() && !AuthCodeValue->IsNull())
      {
          FString TmpValue;
          if (AuthCodeValue->TryGetString(TmpValue)) { AuthCode = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IssuerIdValue = obj->TryGetField(TEXT("IssuerId"));
      if (IssuerIdValue.IsValid() && !IssuerIdValue->IsNull())
      {
          int32 TmpValue;
          if (IssuerIdValue->TryGetNumber(TmpValue)) { IssuerId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> RedirectUriValue = obj->TryGetField(TEXT("RedirectUri"));
      if (RedirectUriValue.IsValid() && !RedirectUriValue->IsNull())
      {
          FString TmpValue;
          if (RedirectUriValue->TryGetString(TmpValue)) { RedirectUri = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkPSNAccountResult::~FLinkPSNAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkPSNAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkPSNAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkSteamAccountRequest::~FLinkSteamAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkSteamAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      writer->WriteIdentifierPrefix(TEXT("SteamTicket")); writer->WriteValue(SteamTicket);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkSteamAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SteamTicketValue = obj->TryGetField(TEXT("SteamTicket"));
      if (SteamTicketValue.IsValid() && !SteamTicketValue->IsNull())
      {
          FString TmpValue;
          if (SteamTicketValue->TryGetString(TmpValue)) { SteamTicket = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkSteamAccountResult::~FLinkSteamAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkSteamAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkSteamAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkTwitchAccountRequest::~FLinkTwitchAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkTwitchAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("AccessToken")); writer->WriteValue(AccessToken);
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkTwitchAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AccessTokenValue = obj->TryGetField(TEXT("AccessToken"));
      if (AccessTokenValue.IsValid() && !AccessTokenValue->IsNull())
      {
          FString TmpValue;
          if (AccessTokenValue->TryGetString(TmpValue)) { AccessToken = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkTwitchAccountResult::~FLinkTwitchAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkTwitchAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkTwitchAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkWindowsHelloAccountRequest::~FLinkWindowsHelloAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkWindowsHelloAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (DeviceName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DeviceName")); writer->WriteValue(DeviceName); }
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      writer->WriteIdentifierPrefix(TEXT("PublicKey")); writer->WriteValue(PublicKey);
  
      writer->WriteIdentifierPrefix(TEXT("UserName")); writer->WriteValue(UserName);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkWindowsHelloAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DeviceNameValue = obj->TryGetField(TEXT("DeviceName"));
      if (DeviceNameValue.IsValid() && !DeviceNameValue->IsNull())
      {
          FString TmpValue;
          if (DeviceNameValue->TryGetString(TmpValue)) { DeviceName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PublicKeyValue = obj->TryGetField(TEXT("PublicKey"));
      if (PublicKeyValue.IsValid() && !PublicKeyValue->IsNull())
      {
          FString TmpValue;
          if (PublicKeyValue->TryGetString(TmpValue)) { PublicKey = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UserNameValue = obj->TryGetField(TEXT("UserName"));
      if (UserNameValue.IsValid() && !UserNameValue->IsNull())
      {
          FString TmpValue;
          if (UserNameValue->TryGetString(TmpValue)) { UserName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkWindowsHelloAccountResponse::~FLinkWindowsHelloAccountResponse()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkWindowsHelloAccountResponse::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkWindowsHelloAccountResponse::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkXboxAccountRequest::~FLinkXboxAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkXboxAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ForceLink.notNull()) { writer->WriteIdentifierPrefix(TEXT("ForceLink")); writer->WriteValue(ForceLink); }
  
      writer->WriteIdentifierPrefix(TEXT("XboxToken")); writer->WriteValue(XboxToken);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkXboxAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ForceLinkValue = obj->TryGetField(TEXT("ForceLink"));
      if (ForceLinkValue.IsValid() && !ForceLinkValue->IsNull())
      {
          bool TmpValue;
          if (ForceLinkValue->TryGetBool(TmpValue)) { ForceLink = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> XboxTokenValue = obj->TryGetField(TEXT("XboxToken"));
      if (XboxTokenValue.IsValid() && !XboxTokenValue->IsNull())
      {
          FString TmpValue;
          if (XboxTokenValue->TryGetString(TmpValue)) { XboxToken = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLinkXboxAccountResult::~FLinkXboxAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FLinkXboxAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLinkXboxAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FListUsersCharactersRequest::~FListUsersCharactersRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FListUsersCharactersRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FListUsersCharactersRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FListUsersCharactersResult::~FListUsersCharactersResult()
  {
  
  }
  
  void PlayFab::ClientModels::FListUsersCharactersResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Characters.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Characters"));
          for (const FCharacterResult& item : Characters)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FListUsersCharactersResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&CharactersArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Characters"));
      for (int32 Idx = 0; Idx < CharactersArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = CharactersArray[Idx];
          Characters.Add(FCharacterResult(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUserSettings::~FUserSettings()
  {
  
  }
  
  void PlayFab::ClientModels::FUserSettings::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("GatherDeviceInfo")); writer->WriteValue(GatherDeviceInfo);
  
      writer->WriteIdentifierPrefix(TEXT("GatherFocusInfo")); writer->WriteValue(GatherFocusInfo);
  
      writer->WriteIdentifierPrefix(TEXT("NeedsAttribution")); writer->WriteValue(NeedsAttribution);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUserSettings::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> GatherDeviceInfoValue = obj->TryGetField(TEXT("GatherDeviceInfo"));
      if (GatherDeviceInfoValue.IsValid() && !GatherDeviceInfoValue->IsNull())
      {
          bool TmpValue;
          if (GatherDeviceInfoValue->TryGetBool(TmpValue)) { GatherDeviceInfo = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GatherFocusInfoValue = obj->TryGetField(TEXT("GatherFocusInfo"));
      if (GatherFocusInfoValue.IsValid() && !GatherFocusInfoValue->IsNull())
      {
          bool TmpValue;
          if (GatherFocusInfoValue->TryGetBool(TmpValue)) { GatherFocusInfo = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> NeedsAttributionValue = obj->TryGetField(TEXT("NeedsAttribution"));
      if (NeedsAttributionValue.IsValid() && !NeedsAttributionValue->IsNull())
      {
          bool TmpValue;
          if (NeedsAttributionValue->TryGetBool(TmpValue)) { NeedsAttribution = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginResult::~FLoginResult()
  {
      //if (EntityToken != nullptr) delete EntityToken;
      //if (InfoResultPayload != nullptr) delete InfoResultPayload;
      //if (SettingsForUser != nullptr) delete SettingsForUser;
  
  }
  
  void PlayFab::ClientModels::FLoginResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (EntityToken.IsValid()) { writer->WriteIdentifierPrefix(TEXT("EntityToken")); EntityToken->writeJSON(writer); }
  
      if (InfoResultPayload.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoResultPayload")); InfoResultPayload->writeJSON(writer); }
  
      if (LastLoginTime.notNull()) { writer->WriteIdentifierPrefix(TEXT("LastLoginTime")); writeDatetime(LastLoginTime, writer); }
  
      writer->WriteIdentifierPrefix(TEXT("NewlyCreated")); writer->WriteValue(NewlyCreated);
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (SessionTicket.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SessionTicket")); writer->WriteValue(SessionTicket); }
  
      if (SettingsForUser.IsValid()) { writer->WriteIdentifierPrefix(TEXT("SettingsForUser")); SettingsForUser->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EntityTokenValue = obj->TryGetField(TEXT("EntityToken"));
      if (EntityTokenValue.IsValid() && !EntityTokenValue->IsNull())
      {
          EntityToken = MakeShareable(new FEntityTokenResponse(EntityTokenValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> InfoResultPayloadValue = obj->TryGetField(TEXT("InfoResultPayload"));
      if (InfoResultPayloadValue.IsValid() && !InfoResultPayloadValue->IsNull())
      {
          InfoResultPayload = MakeShareable(new FGetPlayerCombinedInfoResultPayload(InfoResultPayloadValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> LastLoginTimeValue = obj->TryGetField(TEXT("LastLoginTime"));
      if (LastLoginTimeValue.IsValid())
          LastLoginTime = readDatetime(LastLoginTimeValue);
  
  
      const TSharedPtr<FJsonValue> NewlyCreatedValue = obj->TryGetField(TEXT("NewlyCreated"));
      if (NewlyCreatedValue.IsValid() && !NewlyCreatedValue->IsNull())
      {
          bool TmpValue;
          if (NewlyCreatedValue->TryGetBool(TmpValue)) { NewlyCreated = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SessionTicketValue = obj->TryGetField(TEXT("SessionTicket"));
      if (SessionTicketValue.IsValid() && !SessionTicketValue->IsNull())
      {
          FString TmpValue;
          if (SessionTicketValue->TryGetString(TmpValue)) { SessionTicket = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SettingsForUserValue = obj->TryGetField(TEXT("SettingsForUser"));
      if (SettingsForUserValue.IsValid() && !SettingsForUserValue->IsNull())
      {
          SettingsForUser = MakeShareable(new FUserSettings(SettingsForUserValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithAndroidDeviceIDRequest::~FLoginWithAndroidDeviceIDRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithAndroidDeviceIDRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AndroidDevice.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AndroidDevice")); writer->WriteValue(AndroidDevice); }
  
      if (AndroidDeviceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AndroidDeviceId")); writer->WriteValue(AndroidDeviceId); }
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (OS.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("OS")); writer->WriteValue(OS); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithAndroidDeviceIDRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AndroidDeviceValue = obj->TryGetField(TEXT("AndroidDevice"));
      if (AndroidDeviceValue.IsValid() && !AndroidDeviceValue->IsNull())
      {
          FString TmpValue;
          if (AndroidDeviceValue->TryGetString(TmpValue)) { AndroidDevice = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> AndroidDeviceIdValue = obj->TryGetField(TEXT("AndroidDeviceId"));
      if (AndroidDeviceIdValue.IsValid() && !AndroidDeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (AndroidDeviceIdValue->TryGetString(TmpValue)) { AndroidDeviceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> OSValue = obj->TryGetField(TEXT("OS"));
      if (OSValue.IsValid() && !OSValue->IsNull())
      {
          FString TmpValue;
          if (OSValue->TryGetString(TmpValue)) { OS = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithCustomIDRequest::~FLoginWithCustomIDRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithCustomIDRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (CustomId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CustomId")); writer->WriteValue(CustomId); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithCustomIDRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CustomIdValue = obj->TryGetField(TEXT("CustomId"));
      if (CustomIdValue.IsValid() && !CustomIdValue->IsNull())
      {
          FString TmpValue;
          if (CustomIdValue->TryGetString(TmpValue)) { CustomId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithEmailAddressRequest::~FLoginWithEmailAddressRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithEmailAddressRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Email")); writer->WriteValue(Email);
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      writer->WriteIdentifierPrefix(TEXT("Password")); writer->WriteValue(Password);
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithEmailAddressRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EmailValue = obj->TryGetField(TEXT("Email"));
      if (EmailValue.IsValid() && !EmailValue->IsNull())
      {
          FString TmpValue;
          if (EmailValue->TryGetString(TmpValue)) { Email = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PasswordValue = obj->TryGetField(TEXT("Password"));
      if (PasswordValue.IsValid() && !PasswordValue->IsNull())
      {
          FString TmpValue;
          if (PasswordValue->TryGetString(TmpValue)) { Password = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithFacebookInstantGamesIdRequest::~FLoginWithFacebookInstantGamesIdRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithFacebookInstantGamesIdRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      writer->WriteIdentifierPrefix(TEXT("FacebookInstantGamesSignature")); writer->WriteValue(FacebookInstantGamesSignature);
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithFacebookInstantGamesIdRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> FacebookInstantGamesSignatureValue = obj->TryGetField(TEXT("FacebookInstantGamesSignature"));
      if (FacebookInstantGamesSignatureValue.IsValid() && !FacebookInstantGamesSignatureValue->IsNull())
      {
          FString TmpValue;
          if (FacebookInstantGamesSignatureValue->TryGetString(TmpValue)) { FacebookInstantGamesSignature = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithFacebookRequest::~FLoginWithFacebookRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithFacebookRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("AccessToken")); writer->WriteValue(AccessToken);
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithFacebookRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AccessTokenValue = obj->TryGetField(TEXT("AccessToken"));
      if (AccessTokenValue.IsValid() && !AccessTokenValue->IsNull())
      {
          FString TmpValue;
          if (AccessTokenValue->TryGetString(TmpValue)) { AccessToken = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithGameCenterRequest::~FLoginWithGameCenterRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithGameCenterRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (PlayerId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerId")); writer->WriteValue(PlayerId); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      if (PublicKeyUrl.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PublicKeyUrl")); writer->WriteValue(PublicKeyUrl); }
  
      if (Salt.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Salt")); writer->WriteValue(Salt); }
  
      if (Signature.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Signature")); writer->WriteValue(Signature); }
  
      if (Timestamp.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Timestamp")); writer->WriteValue(Timestamp); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithGameCenterRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayerIdValue = obj->TryGetField(TEXT("PlayerId"));
      if (PlayerIdValue.IsValid() && !PlayerIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayerIdValue->TryGetString(TmpValue)) { PlayerId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PublicKeyUrlValue = obj->TryGetField(TEXT("PublicKeyUrl"));
      if (PublicKeyUrlValue.IsValid() && !PublicKeyUrlValue->IsNull())
      {
          FString TmpValue;
          if (PublicKeyUrlValue->TryGetString(TmpValue)) { PublicKeyUrl = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SaltValue = obj->TryGetField(TEXT("Salt"));
      if (SaltValue.IsValid() && !SaltValue->IsNull())
      {
          FString TmpValue;
          if (SaltValue->TryGetString(TmpValue)) { Salt = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SignatureValue = obj->TryGetField(TEXT("Signature"));
      if (SignatureValue.IsValid() && !SignatureValue->IsNull())
      {
          FString TmpValue;
          if (SignatureValue->TryGetString(TmpValue)) { Signature = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TimestampValue = obj->TryGetField(TEXT("Timestamp"));
      if (TimestampValue.IsValid() && !TimestampValue->IsNull())
      {
          FString TmpValue;
          if (TimestampValue->TryGetString(TmpValue)) { Timestamp = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithGoogleAccountRequest::~FLoginWithGoogleAccountRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithGoogleAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      if (ServerAuthCode.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ServerAuthCode")); writer->WriteValue(ServerAuthCode); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      if (AccessToken.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AccessToken")); writer->WriteValue(AccessToken); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithGoogleAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerAuthCodeValue = obj->TryGetField(TEXT("ServerAuthCode"));
      if (ServerAuthCodeValue.IsValid() && !ServerAuthCodeValue->IsNull())
      {
          FString TmpValue;
          if (ServerAuthCodeValue->TryGetString(TmpValue)) { ServerAuthCode = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> AccessTokenValue = obj->TryGetField(TEXT("AccessToken"));
      if (AccessTokenValue.IsValid() && !AccessTokenValue->IsNull())
      {
          FString TmpValue;
          if (AccessTokenValue->TryGetString(TmpValue)) { AccessToken = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithIOSDeviceIDRequest::~FLoginWithIOSDeviceIDRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithIOSDeviceIDRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (DeviceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DeviceId")); writer->WriteValue(DeviceId); }
  
      if (DeviceModel.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DeviceModel")); writer->WriteValue(DeviceModel); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (OS.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("OS")); writer->WriteValue(OS); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithIOSDeviceIDRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> DeviceIdValue = obj->TryGetField(TEXT("DeviceId"));
      if (DeviceIdValue.IsValid() && !DeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (DeviceIdValue->TryGetString(TmpValue)) { DeviceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> DeviceModelValue = obj->TryGetField(TEXT("DeviceModel"));
      if (DeviceModelValue.IsValid() && !DeviceModelValue->IsNull())
      {
          FString TmpValue;
          if (DeviceModelValue->TryGetString(TmpValue)) { DeviceModel = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> OSValue = obj->TryGetField(TEXT("OS"));
      if (OSValue.IsValid() && !OSValue->IsNull())
      {
          FString TmpValue;
          if (OSValue->TryGetString(TmpValue)) { OS = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithKongregateRequest::~FLoginWithKongregateRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithKongregateRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AuthTicket.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AuthTicket")); writer->WriteValue(AuthTicket); }
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (KongregateId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("KongregateId")); writer->WriteValue(KongregateId); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithKongregateRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AuthTicketValue = obj->TryGetField(TEXT("AuthTicket"));
      if (AuthTicketValue.IsValid() && !AuthTicketValue->IsNull())
      {
          FString TmpValue;
          if (AuthTicketValue->TryGetString(TmpValue)) { AuthTicket = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> KongregateIdValue = obj->TryGetField(TEXT("KongregateId"));
      if (KongregateIdValue.IsValid() && !KongregateIdValue->IsNull())
      {
          FString TmpValue;
          if (KongregateIdValue->TryGetString(TmpValue)) { KongregateId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithNintendoSwitchDeviceIdRequest::~FLoginWithNintendoSwitchDeviceIdRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithNintendoSwitchDeviceIdRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (NintendoSwitchDeviceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("NintendoSwitchDeviceId")); writer->WriteValue(NintendoSwitchDeviceId); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithNintendoSwitchDeviceIdRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> NintendoSwitchDeviceIdValue = obj->TryGetField(TEXT("NintendoSwitchDeviceId"));
      if (NintendoSwitchDeviceIdValue.IsValid() && !NintendoSwitchDeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (NintendoSwitchDeviceIdValue->TryGetString(TmpValue)) { NintendoSwitchDeviceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithOpenIdConnectRequest::~FLoginWithOpenIdConnectRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithOpenIdConnectRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("ConnectionId")); writer->WriteValue(ConnectionId);
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      writer->WriteIdentifierPrefix(TEXT("IdToken")); writer->WriteValue(IdToken);
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithOpenIdConnectRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ConnectionIdValue = obj->TryGetField(TEXT("ConnectionId"));
      if (ConnectionIdValue.IsValid() && !ConnectionIdValue->IsNull())
      {
          FString TmpValue;
          if (ConnectionIdValue->TryGetString(TmpValue)) { ConnectionId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IdTokenValue = obj->TryGetField(TEXT("IdToken"));
      if (IdTokenValue.IsValid() && !IdTokenValue->IsNull())
      {
          FString TmpValue;
          if (IdTokenValue->TryGetString(TmpValue)) { IdToken = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithPlayFabRequest::~FLoginWithPlayFabRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithPlayFabRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      writer->WriteIdentifierPrefix(TEXT("Password")); writer->WriteValue(Password);
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteIdentifierPrefix(TEXT("Username")); writer->WriteValue(Username);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithPlayFabRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PasswordValue = obj->TryGetField(TEXT("Password"));
      if (PasswordValue.IsValid() && !PasswordValue->IsNull())
      {
          FString TmpValue;
          if (PasswordValue->TryGetString(TmpValue)) { Password = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UsernameValue = obj->TryGetField(TEXT("Username"));
      if (UsernameValue.IsValid() && !UsernameValue->IsNull())
      {
          FString TmpValue;
          if (UsernameValue->TryGetString(TmpValue)) { Username = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithPSNRequest::~FLoginWithPSNRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithPSNRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AuthCode.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AuthCode")); writer->WriteValue(AuthCode); }
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (IssuerId.notNull()) { writer->WriteIdentifierPrefix(TEXT("IssuerId")); writer->WriteValue(IssuerId); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      if (RedirectUri.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("RedirectUri")); writer->WriteValue(RedirectUri); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithPSNRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AuthCodeValue = obj->TryGetField(TEXT("AuthCode"));
      if (AuthCodeValue.IsValid() && !AuthCodeValue->IsNull())
      {
          FString TmpValue;
          if (AuthCodeValue->TryGetString(TmpValue)) { AuthCode = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> IssuerIdValue = obj->TryGetField(TEXT("IssuerId"));
      if (IssuerIdValue.IsValid() && !IssuerIdValue->IsNull())
      {
          int32 TmpValue;
          if (IssuerIdValue->TryGetNumber(TmpValue)) { IssuerId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> RedirectUriValue = obj->TryGetField(TEXT("RedirectUri"));
      if (RedirectUriValue.IsValid() && !RedirectUriValue->IsNull())
      {
          FString TmpValue;
          if (RedirectUriValue->TryGetString(TmpValue)) { RedirectUri = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithSteamRequest::~FLoginWithSteamRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithSteamRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      if (SteamTicket.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SteamTicket")); writer->WriteValue(SteamTicket); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithSteamRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SteamTicketValue = obj->TryGetField(TEXT("SteamTicket"));
      if (SteamTicketValue.IsValid() && !SteamTicketValue->IsNull())
      {
          FString TmpValue;
          if (SteamTicketValue->TryGetString(TmpValue)) { SteamTicket = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithTwitchRequest::~FLoginWithTwitchRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithTwitchRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AccessToken.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AccessToken")); writer->WriteValue(AccessToken); }
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithTwitchRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AccessTokenValue = obj->TryGetField(TEXT("AccessToken"));
      if (AccessTokenValue.IsValid() && !AccessTokenValue->IsNull())
      {
          FString TmpValue;
          if (AccessTokenValue->TryGetString(TmpValue)) { AccessToken = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithWindowsHelloRequest::~FLoginWithWindowsHelloRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithWindowsHelloRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("ChallengeSignature")); writer->WriteValue(ChallengeSignature);
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      writer->WriteIdentifierPrefix(TEXT("PublicKeyHint")); writer->WriteValue(PublicKeyHint);
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithWindowsHelloRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ChallengeSignatureValue = obj->TryGetField(TEXT("ChallengeSignature"));
      if (ChallengeSignatureValue.IsValid() && !ChallengeSignatureValue->IsNull())
      {
          FString TmpValue;
          if (ChallengeSignatureValue->TryGetString(TmpValue)) { ChallengeSignature = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PublicKeyHintValue = obj->TryGetField(TEXT("PublicKeyHint"));
      if (PublicKeyHintValue.IsValid() && !PublicKeyHintValue->IsNull())
      {
          FString TmpValue;
          if (PublicKeyHintValue->TryGetString(TmpValue)) { PublicKeyHint = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FLoginWithXboxRequest::~FLoginWithXboxRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FLoginWithXboxRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CreateAccount.notNull()) { writer->WriteIdentifierPrefix(TEXT("CreateAccount")); writer->WriteValue(CreateAccount); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      if (XboxToken.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("XboxToken")); writer->WriteValue(XboxToken); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FLoginWithXboxRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CreateAccountValue = obj->TryGetField(TEXT("CreateAccount"));
      if (CreateAccountValue.IsValid() && !CreateAccountValue->IsNull())
      {
          bool TmpValue;
          if (CreateAccountValue->TryGetBool(TmpValue)) { CreateAccount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> XboxTokenValue = obj->TryGetField(TEXT("XboxToken"));
      if (XboxTokenValue.IsValid() && !XboxTokenValue->IsNull())
      {
          FString TmpValue;
          if (XboxTokenValue->TryGetString(TmpValue)) { XboxToken = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FMatchmakeRequest::~FMatchmakeRequest()
  {
      //if (TagFilter != nullptr) delete TagFilter;
  
  }
  
  void PlayFab::ClientModels::FMatchmakeRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (BuildVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("BuildVersion")); writer->WriteValue(BuildVersion); }
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      if (GameMode.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("GameMode")); writer->WriteValue(GameMode); }
  
      if (LobbyId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("LobbyId")); writer->WriteValue(LobbyId); }
  
      if (pfRegion.notNull()) { writer->WriteIdentifierPrefix(TEXT("Region")); writeRegionEnumJSON(pfRegion, writer); }
  
      if (StartNewIfNoneFound.notNull()) { writer->WriteIdentifierPrefix(TEXT("StartNewIfNoneFound")); writer->WriteValue(StartNewIfNoneFound); }
  
      if (StatisticName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName); }
  
      if (TagFilter.IsValid()) { writer->WriteIdentifierPrefix(TEXT("TagFilter")); TagFilter->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FMatchmakeRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> BuildVersionValue = obj->TryGetField(TEXT("BuildVersion"));
      if (BuildVersionValue.IsValid() && !BuildVersionValue->IsNull())
      {
          FString TmpValue;
          if (BuildVersionValue->TryGetString(TmpValue)) { BuildVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GameModeValue = obj->TryGetField(TEXT("GameMode"));
      if (GameModeValue.IsValid() && !GameModeValue->IsNull())
      {
          FString TmpValue;
          if (GameModeValue->TryGetString(TmpValue)) { GameMode = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> LobbyIdValue = obj->TryGetField(TEXT("LobbyId"));
      if (LobbyIdValue.IsValid() && !LobbyIdValue->IsNull())
      {
          FString TmpValue;
          if (LobbyIdValue->TryGetString(TmpValue)) { LobbyId = TmpValue; }
      }
  
      pfRegion = readRegionFromValue(obj->TryGetField(TEXT("Region")));
  
      const TSharedPtr<FJsonValue> StartNewIfNoneFoundValue = obj->TryGetField(TEXT("StartNewIfNoneFound"));
      if (StartNewIfNoneFoundValue.IsValid() && !StartNewIfNoneFoundValue->IsNull())
      {
          bool TmpValue;
          if (StartNewIfNoneFoundValue->TryGetBool(TmpValue)) { StartNewIfNoneFound = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TagFilterValue = obj->TryGetField(TEXT("TagFilter"));
      if (TagFilterValue.IsValid() && !TagFilterValue->IsNull())
      {
          TagFilter = MakeShareable(new FCollectionFilter(TagFilterValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeMatchmakeStatusEnumJSON(MatchmakeStatus enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case MatchmakeStatusComplete: writer->WriteValue(TEXT("Complete")); break;
      case MatchmakeStatusWaiting: writer->WriteValue(TEXT("Waiting")); break;
      case MatchmakeStatusGameNotFound: writer->WriteValue(TEXT("GameNotFound")); break;
      case MatchmakeStatusNoAvailableSlots: writer->WriteValue(TEXT("NoAvailableSlots")); break;
      case MatchmakeStatusSessionClosed: writer->WriteValue(TEXT("SessionClosed")); break;
      }
  }
  
  ClientModels::MatchmakeStatus PlayFab::ClientModels::readMatchmakeStatusFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readMatchmakeStatusFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::MatchmakeStatus PlayFab::ClientModels::readMatchmakeStatusFromValue(const FString& value)
  {
      static TMap<FString, MatchmakeStatus> _MatchmakeStatusMap;
      if (_MatchmakeStatusMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _MatchmakeStatusMap.Add(TEXT("Complete"), MatchmakeStatusComplete);
          _MatchmakeStatusMap.Add(TEXT("Waiting"), MatchmakeStatusWaiting);
          _MatchmakeStatusMap.Add(TEXT("GameNotFound"), MatchmakeStatusGameNotFound);
          _MatchmakeStatusMap.Add(TEXT("NoAvailableSlots"), MatchmakeStatusNoAvailableSlots);
          _MatchmakeStatusMap.Add(TEXT("SessionClosed"), MatchmakeStatusSessionClosed);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _MatchmakeStatusMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return MatchmakeStatusComplete; // Basically critical fail
  }
  
  PlayFab::ClientModels::FMatchmakeResult::~FMatchmakeResult()
  {
  
  }
  
  void PlayFab::ClientModels::FMatchmakeResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Expires.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Expires")); writer->WriteValue(Expires); }
  
      if (LobbyID.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("LobbyID")); writer->WriteValue(LobbyID); }
  
      if (PollWaitTimeMS.notNull()) { writer->WriteIdentifierPrefix(TEXT("PollWaitTimeMS")); writer->WriteValue(PollWaitTimeMS); }
  
      if (ServerIPV4Address.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ServerIPV4Address")); writer->WriteValue(ServerIPV4Address); }
  
      if (ServerIPV6Address.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ServerIPV6Address")); writer->WriteValue(ServerIPV6Address); }
  
      if (ServerPort.notNull()) { writer->WriteIdentifierPrefix(TEXT("ServerPort")); writer->WriteValue(ServerPort); }
  
      if (ServerPublicDNSName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ServerPublicDNSName")); writer->WriteValue(ServerPublicDNSName); }
  
      if (Status.notNull()) { writer->WriteIdentifierPrefix(TEXT("Status")); writeMatchmakeStatusEnumJSON(Status, writer); }
  
      if (Ticket.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Ticket")); writer->WriteValue(Ticket); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FMatchmakeResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ExpiresValue = obj->TryGetField(TEXT("Expires"));
      if (ExpiresValue.IsValid() && !ExpiresValue->IsNull())
      {
          FString TmpValue;
          if (ExpiresValue->TryGetString(TmpValue)) { Expires = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> LobbyIDValue = obj->TryGetField(TEXT("LobbyID"));
      if (LobbyIDValue.IsValid() && !LobbyIDValue->IsNull())
      {
          FString TmpValue;
          if (LobbyIDValue->TryGetString(TmpValue)) { LobbyID = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PollWaitTimeMSValue = obj->TryGetField(TEXT("PollWaitTimeMS"));
      if (PollWaitTimeMSValue.IsValid() && !PollWaitTimeMSValue->IsNull())
      {
          int32 TmpValue;
          if (PollWaitTimeMSValue->TryGetNumber(TmpValue)) { PollWaitTimeMS = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerIPV4AddressValue = obj->TryGetField(TEXT("ServerIPV4Address"));
      if (ServerIPV4AddressValue.IsValid() && !ServerIPV4AddressValue->IsNull())
      {
          FString TmpValue;
          if (ServerIPV4AddressValue->TryGetString(TmpValue)) { ServerIPV4Address = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerIPV6AddressValue = obj->TryGetField(TEXT("ServerIPV6Address"));
      if (ServerIPV6AddressValue.IsValid() && !ServerIPV6AddressValue->IsNull())
      {
          FString TmpValue;
          if (ServerIPV6AddressValue->TryGetString(TmpValue)) { ServerIPV6Address = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerPortValue = obj->TryGetField(TEXT("ServerPort"));
      if (ServerPortValue.IsValid() && !ServerPortValue->IsNull())
      {
          int32 TmpValue;
          if (ServerPortValue->TryGetNumber(TmpValue)) { ServerPort = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerPublicDNSNameValue = obj->TryGetField(TEXT("ServerPublicDNSName"));
      if (ServerPublicDNSNameValue.IsValid() && !ServerPublicDNSNameValue->IsNull())
      {
          FString TmpValue;
          if (ServerPublicDNSNameValue->TryGetString(TmpValue)) { ServerPublicDNSName = TmpValue; }
      }
  
      Status = readMatchmakeStatusFromValue(obj->TryGetField(TEXT("Status")));
  
      const TSharedPtr<FJsonValue> TicketValue = obj->TryGetField(TEXT("Ticket"));
      if (TicketValue.IsValid() && !TicketValue->IsNull())
      {
          FString TmpValue;
          if (TicketValue->TryGetString(TmpValue)) { Ticket = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FModifyUserVirtualCurrencyResult::~FModifyUserVirtualCurrencyResult()
  {
  
  }
  
  void PlayFab::ClientModels::FModifyUserVirtualCurrencyResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Balance")); writer->WriteValue(Balance);
  
      writer->WriteIdentifierPrefix(TEXT("BalanceChange")); writer->WriteValue(BalanceChange);
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (VirtualCurrency.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("VirtualCurrency")); writer->WriteValue(VirtualCurrency); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FModifyUserVirtualCurrencyResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> BalanceValue = obj->TryGetField(TEXT("Balance"));
      if (BalanceValue.IsValid() && !BalanceValue->IsNull())
      {
          int32 TmpValue;
          if (BalanceValue->TryGetNumber(TmpValue)) { Balance = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> BalanceChangeValue = obj->TryGetField(TEXT("BalanceChange"));
      if (BalanceChangeValue.IsValid() && !BalanceChangeValue->IsNull())
      {
          int32 TmpValue;
          if (BalanceChangeValue->TryGetNumber(TmpValue)) { BalanceChange = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VirtualCurrencyValue = obj->TryGetField(TEXT("VirtualCurrency"));
      if (VirtualCurrencyValue.IsValid() && !VirtualCurrencyValue->IsNull())
      {
          FString TmpValue;
          if (VirtualCurrencyValue->TryGetString(TmpValue)) { VirtualCurrency = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FOpenTradeRequest::~FOpenTradeRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FOpenTradeRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AllowedPlayerIds.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("AllowedPlayerIds"));
          for (const FString& item : AllowedPlayerIds)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (OfferedInventoryInstanceIds.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("OfferedInventoryInstanceIds"));
          for (const FString& item : OfferedInventoryInstanceIds)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (RequestedCatalogItemIds.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("RequestedCatalogItemIds"));
          for (const FString& item : RequestedCatalogItemIds)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FOpenTradeRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      obj->TryGetStringArrayField(TEXT("AllowedPlayerIds"), AllowedPlayerIds);
  
      obj->TryGetStringArrayField(TEXT("OfferedInventoryInstanceIds"), OfferedInventoryInstanceIds);
  
      obj->TryGetStringArrayField(TEXT("RequestedCatalogItemIds"), RequestedCatalogItemIds);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FOpenTradeResponse::~FOpenTradeResponse()
  {
      //if (Trade != nullptr) delete Trade;
  
  }
  
  void PlayFab::ClientModels::FOpenTradeResponse::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Trade.IsValid()) { writer->WriteIdentifierPrefix(TEXT("Trade")); Trade->writeJSON(writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FOpenTradeResponse::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> TradeValue = obj->TryGetField(TEXT("Trade"));
      if (TradeValue.IsValid() && !TradeValue->IsNull())
      {
          Trade = MakeShareable(new FTradeInfo(TradeValue->AsObject()));
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FPayForPurchaseRequest::~FPayForPurchaseRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FPayForPurchaseRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Currency")); writer->WriteValue(Currency);
  
      writer->WriteIdentifierPrefix(TEXT("OrderId")); writer->WriteValue(OrderId);
  
      writer->WriteIdentifierPrefix(TEXT("ProviderName")); writer->WriteValue(ProviderName);
  
      if (ProviderTransactionId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ProviderTransactionId")); writer->WriteValue(ProviderTransactionId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPayForPurchaseRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CurrencyValue = obj->TryGetField(TEXT("Currency"));
      if (CurrencyValue.IsValid() && !CurrencyValue->IsNull())
      {
          FString TmpValue;
          if (CurrencyValue->TryGetString(TmpValue)) { Currency = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> OrderIdValue = obj->TryGetField(TEXT("OrderId"));
      if (OrderIdValue.IsValid() && !OrderIdValue->IsNull())
      {
          FString TmpValue;
          if (OrderIdValue->TryGetString(TmpValue)) { OrderId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProviderNameValue = obj->TryGetField(TEXT("ProviderName"));
      if (ProviderNameValue.IsValid() && !ProviderNameValue->IsNull())
      {
          FString TmpValue;
          if (ProviderNameValue->TryGetString(TmpValue)) { ProviderName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProviderTransactionIdValue = obj->TryGetField(TEXT("ProviderTransactionId"));
      if (ProviderTransactionIdValue.IsValid() && !ProviderTransactionIdValue->IsNull())
      {
          FString TmpValue;
          if (ProviderTransactionIdValue->TryGetString(TmpValue)) { ProviderTransactionId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  void PlayFab::ClientModels::writeTransactionStatusEnumJSON(TransactionStatus enumVal, JsonWriter& writer)
  {
      switch (enumVal)
      {
  
      case TransactionStatusCreateCart: writer->WriteValue(TEXT("CreateCart")); break;
      case TransactionStatusInit: writer->WriteValue(TEXT("Init")); break;
      case TransactionStatusApproved: writer->WriteValue(TEXT("Approved")); break;
      case TransactionStatusSucceeded: writer->WriteValue(TEXT("Succeeded")); break;
      case TransactionStatusFailedByProvider: writer->WriteValue(TEXT("FailedByProvider")); break;
      case TransactionStatusDisputePending: writer->WriteValue(TEXT("DisputePending")); break;
      case TransactionStatusRefundPending: writer->WriteValue(TEXT("RefundPending")); break;
      case TransactionStatusRefunded: writer->WriteValue(TEXT("Refunded")); break;
      case TransactionStatusRefundFailed: writer->WriteValue(TEXT("RefundFailed")); break;
      case TransactionStatusChargedBack: writer->WriteValue(TEXT("ChargedBack")); break;
      case TransactionStatusFailedByUber: writer->WriteValue(TEXT("FailedByUber")); break;
      case TransactionStatusFailedByPlayFab: writer->WriteValue(TEXT("FailedByPlayFab")); break;
      case TransactionStatusRevoked: writer->WriteValue(TEXT("Revoked")); break;
      case TransactionStatusTradePending: writer->WriteValue(TEXT("TradePending")); break;
      case TransactionStatusTraded: writer->WriteValue(TEXT("Traded")); break;
      case TransactionStatusUpgraded: writer->WriteValue(TEXT("Upgraded")); break;
      case TransactionStatusStackPending: writer->WriteValue(TEXT("StackPending")); break;
      case TransactionStatusStacked: writer->WriteValue(TEXT("Stacked")); break;
      case TransactionStatusOther: writer->WriteValue(TEXT("Other")); break;
      case TransactionStatusFailed: writer->WriteValue(TEXT("Failed")); break;
      }
  }
  
  ClientModels::TransactionStatus PlayFab::ClientModels::readTransactionStatusFromValue(const TSharedPtr<FJsonValue>& value)
  {
      return readTransactionStatusFromValue(value.IsValid() ? value->AsString() : "");
  }
  
  ClientModels::TransactionStatus PlayFab::ClientModels::readTransactionStatusFromValue(const FString& value)
  {
      static TMap<FString, TransactionStatus> _TransactionStatusMap;
      if (_TransactionStatusMap.Num() == 0)
      {
          // Auto-generate the map on the first use
          _TransactionStatusMap.Add(TEXT("CreateCart"), TransactionStatusCreateCart);
          _TransactionStatusMap.Add(TEXT("Init"), TransactionStatusInit);
          _TransactionStatusMap.Add(TEXT("Approved"), TransactionStatusApproved);
          _TransactionStatusMap.Add(TEXT("Succeeded"), TransactionStatusSucceeded);
          _TransactionStatusMap.Add(TEXT("FailedByProvider"), TransactionStatusFailedByProvider);
          _TransactionStatusMap.Add(TEXT("DisputePending"), TransactionStatusDisputePending);
          _TransactionStatusMap.Add(TEXT("RefundPending"), TransactionStatusRefundPending);
          _TransactionStatusMap.Add(TEXT("Refunded"), TransactionStatusRefunded);
          _TransactionStatusMap.Add(TEXT("RefundFailed"), TransactionStatusRefundFailed);
          _TransactionStatusMap.Add(TEXT("ChargedBack"), TransactionStatusChargedBack);
          _TransactionStatusMap.Add(TEXT("FailedByUber"), TransactionStatusFailedByUber);
          _TransactionStatusMap.Add(TEXT("FailedByPlayFab"), TransactionStatusFailedByPlayFab);
          _TransactionStatusMap.Add(TEXT("Revoked"), TransactionStatusRevoked);
          _TransactionStatusMap.Add(TEXT("TradePending"), TransactionStatusTradePending);
          _TransactionStatusMap.Add(TEXT("Traded"), TransactionStatusTraded);
          _TransactionStatusMap.Add(TEXT("Upgraded"), TransactionStatusUpgraded);
          _TransactionStatusMap.Add(TEXT("StackPending"), TransactionStatusStackPending);
          _TransactionStatusMap.Add(TEXT("Stacked"), TransactionStatusStacked);
          _TransactionStatusMap.Add(TEXT("Other"), TransactionStatusOther);
          _TransactionStatusMap.Add(TEXT("Failed"), TransactionStatusFailed);
  
      }
  
      if (!value.IsEmpty())
      {
          auto output = _TransactionStatusMap.Find(value);
          if (output != nullptr)
              return *output;
      }
  
      return TransactionStatusCreateCart; // Basically critical fail
  }
  
  PlayFab::ClientModels::FPayForPurchaseResult::~FPayForPurchaseResult()
  {
  
  }
  
  void PlayFab::ClientModels::FPayForPurchaseResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("CreditApplied")); writer->WriteValue(static_cast<int64>(CreditApplied));
  
      if (OrderId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("OrderId")); writer->WriteValue(OrderId); }
  
      if (ProviderData.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ProviderData")); writer->WriteValue(ProviderData); }
  
      if (ProviderToken.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ProviderToken")); writer->WriteValue(ProviderToken); }
  
      if (PurchaseConfirmationPageURL.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PurchaseConfirmationPageURL")); writer->WriteValue(PurchaseConfirmationPageURL); }
  
      if (PurchaseCurrency.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PurchaseCurrency")); writer->WriteValue(PurchaseCurrency); }
  
      writer->WriteIdentifierPrefix(TEXT("PurchasePrice")); writer->WriteValue(static_cast<int64>(PurchasePrice));
  
      if (Status.notNull()) { writer->WriteIdentifierPrefix(TEXT("Status")); writeTransactionStatusEnumJSON(Status, writer); }
  
      if (VCAmount.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VCAmount"));
          for (TMap<FString, int32>::TConstIterator It(VCAmount); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      if (VirtualCurrency.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VirtualCurrency"));
          for (TMap<FString, int32>::TConstIterator It(VirtualCurrency); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPayForPurchaseResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CreditAppliedValue = obj->TryGetField(TEXT("CreditApplied"));
      if (CreditAppliedValue.IsValid() && !CreditAppliedValue->IsNull())
      {
          uint32 TmpValue;
          if (CreditAppliedValue->TryGetNumber(TmpValue)) { CreditApplied = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> OrderIdValue = obj->TryGetField(TEXT("OrderId"));
      if (OrderIdValue.IsValid() && !OrderIdValue->IsNull())
      {
          FString TmpValue;
          if (OrderIdValue->TryGetString(TmpValue)) { OrderId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProviderDataValue = obj->TryGetField(TEXT("ProviderData"));
      if (ProviderDataValue.IsValid() && !ProviderDataValue->IsNull())
      {
          FString TmpValue;
          if (ProviderDataValue->TryGetString(TmpValue)) { ProviderData = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProviderTokenValue = obj->TryGetField(TEXT("ProviderToken"));
      if (ProviderTokenValue.IsValid() && !ProviderTokenValue->IsNull())
      {
          FString TmpValue;
          if (ProviderTokenValue->TryGetString(TmpValue)) { ProviderToken = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PurchaseConfirmationPageURLValue = obj->TryGetField(TEXT("PurchaseConfirmationPageURL"));
      if (PurchaseConfirmationPageURLValue.IsValid() && !PurchaseConfirmationPageURLValue->IsNull())
      {
          FString TmpValue;
          if (PurchaseConfirmationPageURLValue->TryGetString(TmpValue)) { PurchaseConfirmationPageURL = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PurchaseCurrencyValue = obj->TryGetField(TEXT("PurchaseCurrency"));
      if (PurchaseCurrencyValue.IsValid() && !PurchaseCurrencyValue->IsNull())
      {
          FString TmpValue;
          if (PurchaseCurrencyValue->TryGetString(TmpValue)) { PurchaseCurrency = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PurchasePriceValue = obj->TryGetField(TEXT("PurchasePrice"));
      if (PurchasePriceValue.IsValid() && !PurchasePriceValue->IsNull())
      {
          uint32 TmpValue;
          if (PurchasePriceValue->TryGetNumber(TmpValue)) { PurchasePrice = TmpValue; }
      }
  
      Status = readTransactionStatusFromValue(obj->TryGetField(TEXT("Status")));
  
      const TSharedPtr<FJsonObject>* VCAmountObject;
      if (obj->TryGetObjectField(TEXT("VCAmount"), VCAmountObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VCAmountObject)->Values); It; ++It)
          {
              int32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              VCAmount.Add(It.Key(), TmpValue);
          }
      }
  
      const TSharedPtr<FJsonObject>* VirtualCurrencyObject;
      if (obj->TryGetObjectField(TEXT("VirtualCurrency"), VirtualCurrencyObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VirtualCurrencyObject)->Values); It; ++It)
          {
              int32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              VirtualCurrency.Add(It.Key(), TmpValue);
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FPaymentOption::~FPaymentOption()
  {
  
  }
  
  void PlayFab::ClientModels::FPaymentOption::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Currency.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Currency")); writer->WriteValue(Currency); }
  
      writer->WriteIdentifierPrefix(TEXT("Price")); writer->WriteValue(static_cast<int64>(Price));
  
      if (ProviderName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ProviderName")); writer->WriteValue(ProviderName); }
  
      writer->WriteIdentifierPrefix(TEXT("StoreCredit")); writer->WriteValue(static_cast<int64>(StoreCredit));
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPaymentOption::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CurrencyValue = obj->TryGetField(TEXT("Currency"));
      if (CurrencyValue.IsValid() && !CurrencyValue->IsNull())
      {
          FString TmpValue;
          if (CurrencyValue->TryGetString(TmpValue)) { Currency = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PriceValue = obj->TryGetField(TEXT("Price"));
      if (PriceValue.IsValid() && !PriceValue->IsNull())
      {
          uint32 TmpValue;
          if (PriceValue->TryGetNumber(TmpValue)) { Price = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ProviderNameValue = obj->TryGetField(TEXT("ProviderName"));
      if (ProviderNameValue.IsValid() && !ProviderNameValue->IsNull())
      {
          FString TmpValue;
          if (ProviderNameValue->TryGetString(TmpValue)) { ProviderName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StoreCreditValue = obj->TryGetField(TEXT("StoreCredit"));
      if (StoreCreditValue.IsValid() && !StoreCreditValue->IsNull())
      {
          uint32 TmpValue;
          if (StoreCreditValue->TryGetNumber(TmpValue)) { StoreCredit = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FPurchaseItemRequest::~FPurchaseItemRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FPurchaseItemRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      writer->WriteIdentifierPrefix(TEXT("ItemId")); writer->WriteValue(ItemId);
  
      writer->WriteIdentifierPrefix(TEXT("Price")); writer->WriteValue(Price);
  
      if (StoreId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("StoreId")); writer->WriteValue(StoreId); }
  
      writer->WriteIdentifierPrefix(TEXT("VirtualCurrency")); writer->WriteValue(VirtualCurrency);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPurchaseItemRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ItemIdValue = obj->TryGetField(TEXT("ItemId"));
      if (ItemIdValue.IsValid() && !ItemIdValue->IsNull())
      {
          FString TmpValue;
          if (ItemIdValue->TryGetString(TmpValue)) { ItemId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PriceValue = obj->TryGetField(TEXT("Price"));
      if (PriceValue.IsValid() && !PriceValue->IsNull())
      {
          int32 TmpValue;
          if (PriceValue->TryGetNumber(TmpValue)) { Price = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> StoreIdValue = obj->TryGetField(TEXT("StoreId"));
      if (StoreIdValue.IsValid() && !StoreIdValue->IsNull())
      {
          FString TmpValue;
          if (StoreIdValue->TryGetString(TmpValue)) { StoreId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VirtualCurrencyValue = obj->TryGetField(TEXT("VirtualCurrency"));
      if (VirtualCurrencyValue.IsValid() && !VirtualCurrencyValue->IsNull())
      {
          FString TmpValue;
          if (VirtualCurrencyValue->TryGetString(TmpValue)) { VirtualCurrency = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FPurchaseItemResult::~FPurchaseItemResult()
  {
  
  }
  
  void PlayFab::ClientModels::FPurchaseItemResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Items.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Items"));
          for (const FItemInstance& item : Items)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPurchaseItemResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&ItemsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Items"));
      for (int32 Idx = 0; Idx < ItemsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = ItemsArray[Idx];
          Items.Add(FItemInstance(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FPurchaseReceiptFulfillment::~FPurchaseReceiptFulfillment()
  {
  
  }
  
  void PlayFab::ClientModels::FPurchaseReceiptFulfillment::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (FulfilledItems.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("FulfilledItems"));
          for (const FItemInstance& item : FulfilledItems)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (RecordedPriceSource.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("RecordedPriceSource")); writer->WriteValue(RecordedPriceSource); }
  
      if (RecordedTransactionCurrency.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("RecordedTransactionCurrency")); writer->WriteValue(RecordedTransactionCurrency); }
  
      if (RecordedTransactionTotal.notNull()) { writer->WriteIdentifierPrefix(TEXT("RecordedTransactionTotal")); writer->WriteValue(static_cast<int64>(RecordedTransactionTotal)); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FPurchaseReceiptFulfillment::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&FulfilledItemsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("FulfilledItems"));
      for (int32 Idx = 0; Idx < FulfilledItemsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = FulfilledItemsArray[Idx];
          FulfilledItems.Add(FItemInstance(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> RecordedPriceSourceValue = obj->TryGetField(TEXT("RecordedPriceSource"));
      if (RecordedPriceSourceValue.IsValid() && !RecordedPriceSourceValue->IsNull())
      {
          FString TmpValue;
          if (RecordedPriceSourceValue->TryGetString(TmpValue)) { RecordedPriceSource = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> RecordedTransactionCurrencyValue = obj->TryGetField(TEXT("RecordedTransactionCurrency"));
      if (RecordedTransactionCurrencyValue.IsValid() && !RecordedTransactionCurrencyValue->IsNull())
      {
          FString TmpValue;
          if (RecordedTransactionCurrencyValue->TryGetString(TmpValue)) { RecordedTransactionCurrency = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> RecordedTransactionTotalValue = obj->TryGetField(TEXT("RecordedTransactionTotal"));
      if (RecordedTransactionTotalValue.IsValid() && !RecordedTransactionTotalValue->IsNull())
      {
          uint32 TmpValue;
          if (RecordedTransactionTotalValue->TryGetNumber(TmpValue)) { RecordedTransactionTotal = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRedeemCouponRequest::~FRedeemCouponRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FRedeemCouponRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      writer->WriteIdentifierPrefix(TEXT("CouponCode")); writer->WriteValue(CouponCode);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRedeemCouponRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CouponCodeValue = obj->TryGetField(TEXT("CouponCode"));
      if (CouponCodeValue.IsValid() && !CouponCodeValue->IsNull())
      {
          FString TmpValue;
          if (CouponCodeValue->TryGetString(TmpValue)) { CouponCode = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRedeemCouponResult::~FRedeemCouponResult()
  {
  
  }
  
  void PlayFab::ClientModels::FRedeemCouponResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (GrantedItems.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("GrantedItems"));
          for (const FItemInstance& item : GrantedItems)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRedeemCouponResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&GrantedItemsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("GrantedItems"));
      for (int32 Idx = 0; Idx < GrantedItemsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = GrantedItemsArray[Idx];
          GrantedItems.Add(FItemInstance(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRefreshPSNAuthTokenRequest::~FRefreshPSNAuthTokenRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FRefreshPSNAuthTokenRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("AuthCode")); writer->WriteValue(AuthCode);
  
      if (IssuerId.notNull()) { writer->WriteIdentifierPrefix(TEXT("IssuerId")); writer->WriteValue(IssuerId); }
  
      writer->WriteIdentifierPrefix(TEXT("RedirectUri")); writer->WriteValue(RedirectUri);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRefreshPSNAuthTokenRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AuthCodeValue = obj->TryGetField(TEXT("AuthCode"));
      if (AuthCodeValue.IsValid() && !AuthCodeValue->IsNull())
      {
          FString TmpValue;
          if (AuthCodeValue->TryGetString(TmpValue)) { AuthCode = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> IssuerIdValue = obj->TryGetField(TEXT("IssuerId"));
      if (IssuerIdValue.IsValid() && !IssuerIdValue->IsNull())
      {
          int32 TmpValue;
          if (IssuerIdValue->TryGetNumber(TmpValue)) { IssuerId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> RedirectUriValue = obj->TryGetField(TEXT("RedirectUri"));
      if (RedirectUriValue.IsValid() && !RedirectUriValue->IsNull())
      {
          FString TmpValue;
          if (RedirectUriValue->TryGetString(TmpValue)) { RedirectUri = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRegisterForIOSPushNotificationRequest::~FRegisterForIOSPushNotificationRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FRegisterForIOSPushNotificationRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (ConfirmationMessage.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ConfirmationMessage")); writer->WriteValue(ConfirmationMessage); }
  
      writer->WriteIdentifierPrefix(TEXT("DeviceToken")); writer->WriteValue(DeviceToken);
  
      if (SendPushNotificationConfirmation.notNull()) { writer->WriteIdentifierPrefix(TEXT("SendPushNotificationConfirmation")); writer->WriteValue(SendPushNotificationConfirmation); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRegisterForIOSPushNotificationRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ConfirmationMessageValue = obj->TryGetField(TEXT("ConfirmationMessage"));
      if (ConfirmationMessageValue.IsValid() && !ConfirmationMessageValue->IsNull())
      {
          FString TmpValue;
          if (ConfirmationMessageValue->TryGetString(TmpValue)) { ConfirmationMessage = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> DeviceTokenValue = obj->TryGetField(TEXT("DeviceToken"));
      if (DeviceTokenValue.IsValid() && !DeviceTokenValue->IsNull())
      {
          FString TmpValue;
          if (DeviceTokenValue->TryGetString(TmpValue)) { DeviceToken = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SendPushNotificationConfirmationValue = obj->TryGetField(TEXT("SendPushNotificationConfirmation"));
      if (SendPushNotificationConfirmationValue.IsValid() && !SendPushNotificationConfirmationValue->IsNull())
      {
          bool TmpValue;
          if (SendPushNotificationConfirmationValue->TryGetBool(TmpValue)) { SendPushNotificationConfirmation = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRegisterForIOSPushNotificationResult::~FRegisterForIOSPushNotificationResult()
  {
  
  }
  
  void PlayFab::ClientModels::FRegisterForIOSPushNotificationResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRegisterForIOSPushNotificationResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRegisterPlayFabUserRequest::~FRegisterPlayFabUserRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FRegisterPlayFabUserRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (DisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DisplayName")); writer->WriteValue(DisplayName); }
  
      if (Email.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Email")); writer->WriteValue(Email); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (Password.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Password")); writer->WriteValue(Password); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      if (RequireBothUsernameAndEmail.notNull()) { writer->WriteIdentifierPrefix(TEXT("RequireBothUsernameAndEmail")); writer->WriteValue(RequireBothUsernameAndEmail); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      if (Username.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Username")); writer->WriteValue(Username); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRegisterPlayFabUserRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DisplayNameValue = obj->TryGetField(TEXT("DisplayName"));
      if (DisplayNameValue.IsValid() && !DisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (DisplayNameValue->TryGetString(TmpValue)) { DisplayName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EmailValue = obj->TryGetField(TEXT("Email"));
      if (EmailValue.IsValid() && !EmailValue->IsNull())
      {
          FString TmpValue;
          if (EmailValue->TryGetString(TmpValue)) { Email = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PasswordValue = obj->TryGetField(TEXT("Password"));
      if (PasswordValue.IsValid() && !PasswordValue->IsNull())
      {
          FString TmpValue;
          if (PasswordValue->TryGetString(TmpValue)) { Password = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> RequireBothUsernameAndEmailValue = obj->TryGetField(TEXT("RequireBothUsernameAndEmail"));
      if (RequireBothUsernameAndEmailValue.IsValid() && !RequireBothUsernameAndEmailValue->IsNull())
      {
          bool TmpValue;
          if (RequireBothUsernameAndEmailValue->TryGetBool(TmpValue)) { RequireBothUsernameAndEmail = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UsernameValue = obj->TryGetField(TEXT("Username"));
      if (UsernameValue.IsValid() && !UsernameValue->IsNull())
      {
          FString TmpValue;
          if (UsernameValue->TryGetString(TmpValue)) { Username = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRegisterPlayFabUserResult::~FRegisterPlayFabUserResult()
  {
      //if (EntityToken != nullptr) delete EntityToken;
      //if (SettingsForUser != nullptr) delete SettingsForUser;
  
  }
  
  void PlayFab::ClientModels::FRegisterPlayFabUserResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (EntityToken.IsValid()) { writer->WriteIdentifierPrefix(TEXT("EntityToken")); EntityToken->writeJSON(writer); }
  
      if (PlayFabId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayFabId")); writer->WriteValue(PlayFabId); }
  
      if (SessionTicket.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("SessionTicket")); writer->WriteValue(SessionTicket); }
  
      if (SettingsForUser.IsValid()) { writer->WriteIdentifierPrefix(TEXT("SettingsForUser")); SettingsForUser->writeJSON(writer); }
  
      if (Username.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Username")); writer->WriteValue(Username); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRegisterPlayFabUserResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EntityTokenValue = obj->TryGetField(TEXT("EntityToken"));
      if (EntityTokenValue.IsValid() && !EntityTokenValue->IsNull())
      {
          EntityToken = MakeShareable(new FEntityTokenResponse(EntityTokenValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayFabIdValue = obj->TryGetField(TEXT("PlayFabId"));
      if (PlayFabIdValue.IsValid() && !PlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (PlayFabIdValue->TryGetString(TmpValue)) { PlayFabId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SessionTicketValue = obj->TryGetField(TEXT("SessionTicket"));
      if (SessionTicketValue.IsValid() && !SessionTicketValue->IsNull())
      {
          FString TmpValue;
          if (SessionTicketValue->TryGetString(TmpValue)) { SessionTicket = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SettingsForUserValue = obj->TryGetField(TEXT("SettingsForUser"));
      if (SettingsForUserValue.IsValid() && !SettingsForUserValue->IsNull())
      {
          SettingsForUser = MakeShareable(new FUserSettings(SettingsForUserValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> UsernameValue = obj->TryGetField(TEXT("Username"));
      if (UsernameValue.IsValid() && !UsernameValue->IsNull())
      {
          FString TmpValue;
          if (UsernameValue->TryGetString(TmpValue)) { Username = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRegisterWithWindowsHelloRequest::~FRegisterWithWindowsHelloRequest()
  {
      //if (InfoRequestParameters != nullptr) delete InfoRequestParameters;
  
  }
  
  void PlayFab::ClientModels::FRegisterWithWindowsHelloRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (DeviceName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DeviceName")); writer->WriteValue(DeviceName); }
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (InfoRequestParameters.IsValid()) { writer->WriteIdentifierPrefix(TEXT("InfoRequestParameters")); InfoRequestParameters->writeJSON(writer); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      if (PublicKey.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PublicKey")); writer->WriteValue(PublicKey); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      if (UserName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("UserName")); writer->WriteValue(UserName); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRegisterWithWindowsHelloRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DeviceNameValue = obj->TryGetField(TEXT("DeviceName"));
      if (DeviceNameValue.IsValid() && !DeviceNameValue->IsNull())
      {
          FString TmpValue;
          if (DeviceNameValue->TryGetString(TmpValue)) { DeviceName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> InfoRequestParametersValue = obj->TryGetField(TEXT("InfoRequestParameters"));
      if (InfoRequestParametersValue.IsValid() && !InfoRequestParametersValue->IsNull())
      {
          InfoRequestParameters = MakeShareable(new FGetPlayerCombinedInfoRequestParams(InfoRequestParametersValue->AsObject()));
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PublicKeyValue = obj->TryGetField(TEXT("PublicKey"));
      if (PublicKeyValue.IsValid() && !PublicKeyValue->IsNull())
      {
          FString TmpValue;
          if (PublicKeyValue->TryGetString(TmpValue)) { PublicKey = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UserNameValue = obj->TryGetField(TEXT("UserName"));
      if (UserNameValue.IsValid() && !UserNameValue->IsNull())
      {
          FString TmpValue;
          if (UserNameValue->TryGetString(TmpValue)) { UserName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRemoveContactEmailRequest::~FRemoveContactEmailRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FRemoveContactEmailRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRemoveContactEmailRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRemoveContactEmailResult::~FRemoveContactEmailResult()
  {
  
  }
  
  void PlayFab::ClientModels::FRemoveContactEmailResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRemoveContactEmailResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRemoveFriendRequest::~FRemoveFriendRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FRemoveFriendRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("FriendPlayFabId")); writer->WriteValue(FriendPlayFabId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRemoveFriendRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> FriendPlayFabIdValue = obj->TryGetField(TEXT("FriendPlayFabId"));
      if (FriendPlayFabIdValue.IsValid() && !FriendPlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (FriendPlayFabIdValue->TryGetString(TmpValue)) { FriendPlayFabId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRemoveFriendResult::~FRemoveFriendResult()
  {
  
  }
  
  void PlayFab::ClientModels::FRemoveFriendResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRemoveFriendResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRemoveGenericIDRequest::~FRemoveGenericIDRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FRemoveGenericIDRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("GenericId")); GenericId.writeJSON(writer);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRemoveGenericIDRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> GenericIdValue = obj->TryGetField(TEXT("GenericId"));
      if (GenericIdValue.IsValid() && !GenericIdValue->IsNull())
      {
          GenericId = FGenericServiceId(GenericIdValue->AsObject());
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRemoveGenericIDResult::~FRemoveGenericIDResult()
  {
  
  }
  
  void PlayFab::ClientModels::FRemoveGenericIDResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRemoveGenericIDResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRemoveSharedGroupMembersRequest::~FRemoveSharedGroupMembersRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FRemoveSharedGroupMembersRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("PlayFabIds"));
      for (const FString& item : PlayFabIds)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteIdentifierPrefix(TEXT("SharedGroupId")); writer->WriteValue(SharedGroupId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRemoveSharedGroupMembersRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("PlayFabIds"), PlayFabIds);
  
      const TSharedPtr<FJsonValue> SharedGroupIdValue = obj->TryGetField(TEXT("SharedGroupId"));
      if (SharedGroupIdValue.IsValid() && !SharedGroupIdValue->IsNull())
      {
          FString TmpValue;
          if (SharedGroupIdValue->TryGetString(TmpValue)) { SharedGroupId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRemoveSharedGroupMembersResult::~FRemoveSharedGroupMembersResult()
  {
  
  }
  
  void PlayFab::ClientModels::FRemoveSharedGroupMembersResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRemoveSharedGroupMembersResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FReportPlayerClientRequest::~FReportPlayerClientRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FReportPlayerClientRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Comment.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Comment")); writer->WriteValue(Comment); }
  
      writer->WriteIdentifierPrefix(TEXT("ReporteeId")); writer->WriteValue(ReporteeId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FReportPlayerClientRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CommentValue = obj->TryGetField(TEXT("Comment"));
      if (CommentValue.IsValid() && !CommentValue->IsNull())
      {
          FString TmpValue;
          if (CommentValue->TryGetString(TmpValue)) { Comment = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ReporteeIdValue = obj->TryGetField(TEXT("ReporteeId"));
      if (ReporteeIdValue.IsValid() && !ReporteeIdValue->IsNull())
      {
          FString TmpValue;
          if (ReporteeIdValue->TryGetString(TmpValue)) { ReporteeId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FReportPlayerClientResult::~FReportPlayerClientResult()
  {
  
  }
  
  void PlayFab::ClientModels::FReportPlayerClientResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("SubmissionsRemaining")); writer->WriteValue(SubmissionsRemaining);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FReportPlayerClientResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> SubmissionsRemainingValue = obj->TryGetField(TEXT("SubmissionsRemaining"));
      if (SubmissionsRemainingValue.IsValid() && !SubmissionsRemainingValue->IsNull())
      {
          int32 TmpValue;
          if (SubmissionsRemainingValue->TryGetNumber(TmpValue)) { SubmissionsRemaining = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRestoreIOSPurchasesRequest::~FRestoreIOSPurchasesRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FRestoreIOSPurchasesRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      writer->WriteIdentifierPrefix(TEXT("ReceiptData")); writer->WriteValue(ReceiptData);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRestoreIOSPurchasesRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ReceiptDataValue = obj->TryGetField(TEXT("ReceiptData"));
      if (ReceiptDataValue.IsValid() && !ReceiptDataValue->IsNull())
      {
          FString TmpValue;
          if (ReceiptDataValue->TryGetString(TmpValue)) { ReceiptData = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FRestoreIOSPurchasesResult::~FRestoreIOSPurchasesResult()
  {
  
  }
  
  void PlayFab::ClientModels::FRestoreIOSPurchasesResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Fulfillments.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Fulfillments"));
          for (const FPurchaseReceiptFulfillment& item : Fulfillments)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FRestoreIOSPurchasesResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&FulfillmentsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Fulfillments"));
      for (int32 Idx = 0; Idx < FulfillmentsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = FulfillmentsArray[Idx];
          Fulfillments.Add(FPurchaseReceiptFulfillment(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FSendAccountRecoveryEmailRequest::~FSendAccountRecoveryEmailRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FSendAccountRecoveryEmailRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Email")); writer->WriteValue(Email);
  
      if (EmailTemplateId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EmailTemplateId")); writer->WriteValue(EmailTemplateId); }
  
      writer->WriteIdentifierPrefix(TEXT("TitleId")); writer->WriteValue(TitleId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FSendAccountRecoveryEmailRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EmailValue = obj->TryGetField(TEXT("Email"));
      if (EmailValue.IsValid() && !EmailValue->IsNull())
      {
          FString TmpValue;
          if (EmailValue->TryGetString(TmpValue)) { Email = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EmailTemplateIdValue = obj->TryGetField(TEXT("EmailTemplateId"));
      if (EmailTemplateIdValue.IsValid() && !EmailTemplateIdValue->IsNull())
      {
          FString TmpValue;
          if (EmailTemplateIdValue->TryGetString(TmpValue)) { EmailTemplateId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TitleIdValue = obj->TryGetField(TEXT("TitleId"));
      if (TitleIdValue.IsValid() && !TitleIdValue->IsNull())
      {
          FString TmpValue;
          if (TitleIdValue->TryGetString(TmpValue)) { TitleId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FSendAccountRecoveryEmailResult::~FSendAccountRecoveryEmailResult()
  {
  
  }
  
  void PlayFab::ClientModels::FSendAccountRecoveryEmailResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FSendAccountRecoveryEmailResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FSetFriendTagsRequest::~FSetFriendTagsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FSetFriendTagsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("FriendPlayFabId")); writer->WriteValue(FriendPlayFabId);
  
      writer->WriteArrayStart(TEXT("Tags"));
      for (const FString& item : Tags)
          writer->WriteValue(item);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FSetFriendTagsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> FriendPlayFabIdValue = obj->TryGetField(TEXT("FriendPlayFabId"));
      if (FriendPlayFabIdValue.IsValid() && !FriendPlayFabIdValue->IsNull())
      {
          FString TmpValue;
          if (FriendPlayFabIdValue->TryGetString(TmpValue)) { FriendPlayFabId = TmpValue; }
      }
  
      HasSucceeded &= obj->TryGetStringArrayField(TEXT("Tags"), Tags);
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FSetFriendTagsResult::~FSetFriendTagsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FSetFriendTagsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FSetFriendTagsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FSetPlayerSecretRequest::~FSetPlayerSecretRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FSetPlayerSecretRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (EncryptedRequest.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EncryptedRequest")); writer->WriteValue(EncryptedRequest); }
  
      if (PlayerSecret.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("PlayerSecret")); writer->WriteValue(PlayerSecret); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FSetPlayerSecretRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EncryptedRequestValue = obj->TryGetField(TEXT("EncryptedRequest"));
      if (EncryptedRequestValue.IsValid() && !EncryptedRequestValue->IsNull())
      {
          FString TmpValue;
          if (EncryptedRequestValue->TryGetString(TmpValue)) { EncryptedRequest = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PlayerSecretValue = obj->TryGetField(TEXT("PlayerSecret"));
      if (PlayerSecretValue.IsValid() && !PlayerSecretValue->IsNull())
      {
          FString TmpValue;
          if (PlayerSecretValue->TryGetString(TmpValue)) { PlayerSecret = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FSetPlayerSecretResult::~FSetPlayerSecretResult()
  {
  
  }
  
  void PlayFab::ClientModels::FSetPlayerSecretResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FSetPlayerSecretResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FStartGameRequest::~FStartGameRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FStartGameRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("BuildVersion")); writer->WriteValue(BuildVersion);
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      if (CustomCommandLineData.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CustomCommandLineData")); writer->WriteValue(CustomCommandLineData); }
  
      writer->WriteIdentifierPrefix(TEXT("GameMode")); writer->WriteValue(GameMode);
  
      writer->WriteIdentifierPrefix(TEXT("Region")); writeRegionEnumJSON(pfRegion, writer);
  
      if (StatisticName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FStartGameRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> BuildVersionValue = obj->TryGetField(TEXT("BuildVersion"));
      if (BuildVersionValue.IsValid() && !BuildVersionValue->IsNull())
      {
          FString TmpValue;
          if (BuildVersionValue->TryGetString(TmpValue)) { BuildVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CustomCommandLineDataValue = obj->TryGetField(TEXT("CustomCommandLineData"));
      if (CustomCommandLineDataValue.IsValid() && !CustomCommandLineDataValue->IsNull())
      {
          FString TmpValue;
          if (CustomCommandLineDataValue->TryGetString(TmpValue)) { CustomCommandLineData = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> GameModeValue = obj->TryGetField(TEXT("GameMode"));
      if (GameModeValue.IsValid() && !GameModeValue->IsNull())
      {
          FString TmpValue;
          if (GameModeValue->TryGetString(TmpValue)) { GameMode = TmpValue; }
      }
  
      pfRegion = readRegionFromValue(obj->TryGetField(TEXT("Region")));
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FStartGameResult::~FStartGameResult()
  {
  
  }
  
  void PlayFab::ClientModels::FStartGameResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Expires.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Expires")); writer->WriteValue(Expires); }
  
      if (LobbyID.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("LobbyID")); writer->WriteValue(LobbyID); }
  
      if (Password.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Password")); writer->WriteValue(Password); }
  
      if (ServerIPV4Address.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ServerIPV4Address")); writer->WriteValue(ServerIPV4Address); }
  
      if (ServerIPV6Address.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ServerIPV6Address")); writer->WriteValue(ServerIPV6Address); }
  
      if (ServerPort.notNull()) { writer->WriteIdentifierPrefix(TEXT("ServerPort")); writer->WriteValue(ServerPort); }
  
      if (ServerPublicDNSName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("ServerPublicDNSName")); writer->WriteValue(ServerPublicDNSName); }
  
      if (Ticket.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("Ticket")); writer->WriteValue(Ticket); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FStartGameResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ExpiresValue = obj->TryGetField(TEXT("Expires"));
      if (ExpiresValue.IsValid() && !ExpiresValue->IsNull())
      {
          FString TmpValue;
          if (ExpiresValue->TryGetString(TmpValue)) { Expires = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> LobbyIDValue = obj->TryGetField(TEXT("LobbyID"));
      if (LobbyIDValue.IsValid() && !LobbyIDValue->IsNull())
      {
          FString TmpValue;
          if (LobbyIDValue->TryGetString(TmpValue)) { LobbyID = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PasswordValue = obj->TryGetField(TEXT("Password"));
      if (PasswordValue.IsValid() && !PasswordValue->IsNull())
      {
          FString TmpValue;
          if (PasswordValue->TryGetString(TmpValue)) { Password = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerIPV4AddressValue = obj->TryGetField(TEXT("ServerIPV4Address"));
      if (ServerIPV4AddressValue.IsValid() && !ServerIPV4AddressValue->IsNull())
      {
          FString TmpValue;
          if (ServerIPV4AddressValue->TryGetString(TmpValue)) { ServerIPV4Address = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerIPV6AddressValue = obj->TryGetField(TEXT("ServerIPV6Address"));
      if (ServerIPV6AddressValue.IsValid() && !ServerIPV6AddressValue->IsNull())
      {
          FString TmpValue;
          if (ServerIPV6AddressValue->TryGetString(TmpValue)) { ServerIPV6Address = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerPortValue = obj->TryGetField(TEXT("ServerPort"));
      if (ServerPortValue.IsValid() && !ServerPortValue->IsNull())
      {
          int32 TmpValue;
          if (ServerPortValue->TryGetNumber(TmpValue)) { ServerPort = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ServerPublicDNSNameValue = obj->TryGetField(TEXT("ServerPublicDNSName"));
      if (ServerPublicDNSNameValue.IsValid() && !ServerPublicDNSNameValue->IsNull())
      {
          FString TmpValue;
          if (ServerPublicDNSNameValue->TryGetString(TmpValue)) { ServerPublicDNSName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TicketValue = obj->TryGetField(TEXT("Ticket"));
      if (TicketValue.IsValid() && !TicketValue->IsNull())
      {
          FString TmpValue;
          if (TicketValue->TryGetString(TmpValue)) { Ticket = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FStartPurchaseRequest::~FStartPurchaseRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FStartPurchaseRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      writer->WriteArrayStart(TEXT("Items"));
      for (const FItemPurchaseRequest& item : Items)
          item.writeJSON(writer);
      writer->WriteArrayEnd();
  
  
      if (StoreId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("StoreId")); writer->WriteValue(StoreId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FStartPurchaseRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TArray<TSharedPtr<FJsonValue>>&ItemsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Items"));
      for (int32 Idx = 0; Idx < ItemsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = ItemsArray[Idx];
          Items.Add(FItemPurchaseRequest(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> StoreIdValue = obj->TryGetField(TEXT("StoreId"));
      if (StoreIdValue.IsValid() && !StoreIdValue->IsNull())
      {
          FString TmpValue;
          if (StoreIdValue->TryGetString(TmpValue)) { StoreId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FStartPurchaseResult::~FStartPurchaseResult()
  {
  
  }
  
  void PlayFab::ClientModels::FStartPurchaseResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Contents.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Contents"));
          for (const FCartItem& item : Contents)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (OrderId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("OrderId")); writer->WriteValue(OrderId); }
  
      if (PaymentOptions.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("PaymentOptions"));
          for (const FPaymentOption& item : PaymentOptions)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (VirtualCurrencyBalances.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VirtualCurrencyBalances"));
          for (TMap<FString, int32>::TConstIterator It(VirtualCurrencyBalances); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FStartPurchaseResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&ContentsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Contents"));
      for (int32 Idx = 0; Idx < ContentsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = ContentsArray[Idx];
          Contents.Add(FCartItem(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> OrderIdValue = obj->TryGetField(TEXT("OrderId"));
      if (OrderIdValue.IsValid() && !OrderIdValue->IsNull())
      {
          FString TmpValue;
          if (OrderIdValue->TryGetString(TmpValue)) { OrderId = TmpValue; }
      }
  
      const TArray<TSharedPtr<FJsonValue>>&PaymentOptionsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("PaymentOptions"));
      for (int32 Idx = 0; Idx < PaymentOptionsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = PaymentOptionsArray[Idx];
          PaymentOptions.Add(FPaymentOption(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonObject>* VirtualCurrencyBalancesObject;
      if (obj->TryGetObjectField(TEXT("VirtualCurrencyBalances"), VirtualCurrencyBalancesObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VirtualCurrencyBalancesObject)->Values); It; ++It)
          {
              int32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              VirtualCurrencyBalances.Add(It.Key(), TmpValue);
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FStatisticUpdate::~FStatisticUpdate()
  {
  
  }
  
  void PlayFab::ClientModels::FStatisticUpdate::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("StatisticName")); writer->WriteValue(StatisticName);
  
      writer->WriteIdentifierPrefix(TEXT("Value")); writer->WriteValue(Value);
  
      if (Version.notNull()) { writer->WriteIdentifierPrefix(TEXT("Version")); writer->WriteValue(static_cast<int64>(Version)); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FStatisticUpdate::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> StatisticNameValue = obj->TryGetField(TEXT("StatisticName"));
      if (StatisticNameValue.IsValid() && !StatisticNameValue->IsNull())
      {
          FString TmpValue;
          if (StatisticNameValue->TryGetString(TmpValue)) { StatisticName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ValueValue = obj->TryGetField(TEXT("Value"));
      if (ValueValue.IsValid() && !ValueValue->IsNull())
      {
          int32 TmpValue;
          if (ValueValue->TryGetNumber(TmpValue)) { Value = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VersionValue = obj->TryGetField(TEXT("Version"));
      if (VersionValue.IsValid() && !VersionValue->IsNull())
      {
          uint32 TmpValue;
          if (VersionValue->TryGetNumber(TmpValue)) { Version = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FSubtractUserVirtualCurrencyRequest::~FSubtractUserVirtualCurrencyRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FSubtractUserVirtualCurrencyRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("Amount")); writer->WriteValue(Amount);
  
      writer->WriteIdentifierPrefix(TEXT("VirtualCurrency")); writer->WriteValue(VirtualCurrency);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FSubtractUserVirtualCurrencyRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AmountValue = obj->TryGetField(TEXT("Amount"));
      if (AmountValue.IsValid() && !AmountValue->IsNull())
      {
          int32 TmpValue;
          if (AmountValue->TryGetNumber(TmpValue)) { Amount = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> VirtualCurrencyValue = obj->TryGetField(TEXT("VirtualCurrency"));
      if (VirtualCurrencyValue.IsValid() && !VirtualCurrencyValue->IsNull())
      {
          FString TmpValue;
          if (VirtualCurrencyValue->TryGetString(TmpValue)) { VirtualCurrency = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUninkOpenIdConnectRequest::~FUninkOpenIdConnectRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUninkOpenIdConnectRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("ConnectionId")); writer->WriteValue(ConnectionId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUninkOpenIdConnectRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ConnectionIdValue = obj->TryGetField(TEXT("ConnectionId"));
      if (ConnectionIdValue.IsValid() && !ConnectionIdValue->IsNull())
      {
          FString TmpValue;
          if (ConnectionIdValue->TryGetString(TmpValue)) { ConnectionId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkAndroidDeviceIDRequest::~FUnlinkAndroidDeviceIDRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkAndroidDeviceIDRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (AndroidDeviceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("AndroidDeviceId")); writer->WriteValue(AndroidDeviceId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkAndroidDeviceIDRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> AndroidDeviceIdValue = obj->TryGetField(TEXT("AndroidDeviceId"));
      if (AndroidDeviceIdValue.IsValid() && !AndroidDeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (AndroidDeviceIdValue->TryGetString(TmpValue)) { AndroidDeviceId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkAndroidDeviceIDResult::~FUnlinkAndroidDeviceIDResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkAndroidDeviceIDResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkAndroidDeviceIDResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkCustomIDRequest::~FUnlinkCustomIDRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkCustomIDRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CustomId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CustomId")); writer->WriteValue(CustomId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkCustomIDRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CustomIdValue = obj->TryGetField(TEXT("CustomId"));
      if (CustomIdValue.IsValid() && !CustomIdValue->IsNull())
      {
          FString TmpValue;
          if (CustomIdValue->TryGetString(TmpValue)) { CustomId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkCustomIDResult::~FUnlinkCustomIDResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkCustomIDResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkCustomIDResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkFacebookAccountRequest::~FUnlinkFacebookAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkFacebookAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkFacebookAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkFacebookAccountResult::~FUnlinkFacebookAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkFacebookAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkFacebookAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkFacebookInstantGamesIdRequest::~FUnlinkFacebookInstantGamesIdRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkFacebookInstantGamesIdRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (FacebookInstantGamesId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("FacebookInstantGamesId")); writer->WriteValue(FacebookInstantGamesId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkFacebookInstantGamesIdRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> FacebookInstantGamesIdValue = obj->TryGetField(TEXT("FacebookInstantGamesId"));
      if (FacebookInstantGamesIdValue.IsValid() && !FacebookInstantGamesIdValue->IsNull())
      {
          FString TmpValue;
          if (FacebookInstantGamesIdValue->TryGetString(TmpValue)) { FacebookInstantGamesId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkFacebookInstantGamesIdResult::~FUnlinkFacebookInstantGamesIdResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkFacebookInstantGamesIdResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkFacebookInstantGamesIdResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkGameCenterAccountRequest::~FUnlinkGameCenterAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkGameCenterAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkGameCenterAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkGameCenterAccountResult::~FUnlinkGameCenterAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkGameCenterAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkGameCenterAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkGoogleAccountRequest::~FUnlinkGoogleAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkGoogleAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkGoogleAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkGoogleAccountResult::~FUnlinkGoogleAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkGoogleAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkGoogleAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkIOSDeviceIDRequest::~FUnlinkIOSDeviceIDRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkIOSDeviceIDRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (DeviceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DeviceId")); writer->WriteValue(DeviceId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkIOSDeviceIDRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DeviceIdValue = obj->TryGetField(TEXT("DeviceId"));
      if (DeviceIdValue.IsValid() && !DeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (DeviceIdValue->TryGetString(TmpValue)) { DeviceId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkIOSDeviceIDResult::~FUnlinkIOSDeviceIDResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkIOSDeviceIDResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkIOSDeviceIDResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkKongregateAccountRequest::~FUnlinkKongregateAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkKongregateAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkKongregateAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkKongregateAccountResult::~FUnlinkKongregateAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkKongregateAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkKongregateAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkNintendoSwitchDeviceIdRequest::~FUnlinkNintendoSwitchDeviceIdRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkNintendoSwitchDeviceIdRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (NintendoSwitchDeviceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("NintendoSwitchDeviceId")); writer->WriteValue(NintendoSwitchDeviceId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkNintendoSwitchDeviceIdRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> NintendoSwitchDeviceIdValue = obj->TryGetField(TEXT("NintendoSwitchDeviceId"));
      if (NintendoSwitchDeviceIdValue.IsValid() && !NintendoSwitchDeviceIdValue->IsNull())
      {
          FString TmpValue;
          if (NintendoSwitchDeviceIdValue->TryGetString(TmpValue)) { NintendoSwitchDeviceId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkNintendoSwitchDeviceIdResult::~FUnlinkNintendoSwitchDeviceIdResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkNintendoSwitchDeviceIdResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkNintendoSwitchDeviceIdResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkPSNAccountRequest::~FUnlinkPSNAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkPSNAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkPSNAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkPSNAccountResult::~FUnlinkPSNAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkPSNAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkPSNAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkSteamAccountRequest::~FUnlinkSteamAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkSteamAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkSteamAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkSteamAccountResult::~FUnlinkSteamAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkSteamAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkSteamAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkTwitchAccountRequest::~FUnlinkTwitchAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkTwitchAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkTwitchAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkTwitchAccountResult::~FUnlinkTwitchAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkTwitchAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkTwitchAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkWindowsHelloAccountRequest::~FUnlinkWindowsHelloAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkWindowsHelloAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("PublicKeyHint")); writer->WriteValue(PublicKeyHint);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkWindowsHelloAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> PublicKeyHintValue = obj->TryGetField(TEXT("PublicKeyHint"));
      if (PublicKeyHintValue.IsValid() && !PublicKeyHintValue->IsNull())
      {
          FString TmpValue;
          if (PublicKeyHintValue->TryGetString(TmpValue)) { PublicKeyHint = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkWindowsHelloAccountResponse::~FUnlinkWindowsHelloAccountResponse()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkWindowsHelloAccountResponse::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkWindowsHelloAccountResponse::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkXboxAccountRequest::~FUnlinkXboxAccountRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkXboxAccountRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("XboxToken")); writer->WriteValue(XboxToken);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkXboxAccountRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> XboxTokenValue = obj->TryGetField(TEXT("XboxToken"));
      if (XboxTokenValue.IsValid() && !XboxTokenValue->IsNull())
      {
          FString TmpValue;
          if (XboxTokenValue->TryGetString(TmpValue)) { XboxToken = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlinkXboxAccountResult::~FUnlinkXboxAccountResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlinkXboxAccountResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlinkXboxAccountResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlockContainerInstanceRequest::~FUnlockContainerInstanceRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlockContainerInstanceRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      writer->WriteIdentifierPrefix(TEXT("ContainerItemInstanceId")); writer->WriteValue(ContainerItemInstanceId);
  
      if (KeyItemInstanceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("KeyItemInstanceId")); writer->WriteValue(KeyItemInstanceId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlockContainerInstanceRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ContainerItemInstanceIdValue = obj->TryGetField(TEXT("ContainerItemInstanceId"));
      if (ContainerItemInstanceIdValue.IsValid() && !ContainerItemInstanceIdValue->IsNull())
      {
          FString TmpValue;
          if (ContainerItemInstanceIdValue->TryGetString(TmpValue)) { ContainerItemInstanceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> KeyItemInstanceIdValue = obj->TryGetField(TEXT("KeyItemInstanceId"));
      if (KeyItemInstanceIdValue.IsValid() && !KeyItemInstanceIdValue->IsNull())
      {
          FString TmpValue;
          if (KeyItemInstanceIdValue->TryGetString(TmpValue)) { KeyItemInstanceId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlockContainerItemRequest::~FUnlockContainerItemRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlockContainerItemRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      if (CharacterId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId); }
  
      writer->WriteIdentifierPrefix(TEXT("ContainerItemId")); writer->WriteValue(ContainerItemId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlockContainerItemRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ContainerItemIdValue = obj->TryGetField(TEXT("ContainerItemId"));
      if (ContainerItemIdValue.IsValid() && !ContainerItemIdValue->IsNull())
      {
          FString TmpValue;
          if (ContainerItemIdValue->TryGetString(TmpValue)) { ContainerItemId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUnlockContainerItemResult::~FUnlockContainerItemResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUnlockContainerItemResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (GrantedItems.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("GrantedItems"));
          for (const FItemInstance& item : GrantedItems)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      if (UnlockedItemInstanceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("UnlockedItemInstanceId")); writer->WriteValue(UnlockedItemInstanceId); }
  
      if (UnlockedWithItemInstanceId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("UnlockedWithItemInstanceId")); writer->WriteValue(UnlockedWithItemInstanceId); }
  
      if (VirtualCurrency.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("VirtualCurrency"));
          for (TMap<FString, uint32>::TConstIterator It(VirtualCurrency); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue(static_cast<int64>((*It).Value));
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUnlockContainerItemResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&GrantedItemsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("GrantedItems"));
      for (int32 Idx = 0; Idx < GrantedItemsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = GrantedItemsArray[Idx];
          GrantedItems.Add(FItemInstance(CurrentItem->AsObject()));
      }
  
  
      const TSharedPtr<FJsonValue> UnlockedItemInstanceIdValue = obj->TryGetField(TEXT("UnlockedItemInstanceId"));
      if (UnlockedItemInstanceIdValue.IsValid() && !UnlockedItemInstanceIdValue->IsNull())
      {
          FString TmpValue;
          if (UnlockedItemInstanceIdValue->TryGetString(TmpValue)) { UnlockedItemInstanceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UnlockedWithItemInstanceIdValue = obj->TryGetField(TEXT("UnlockedWithItemInstanceId"));
      if (UnlockedWithItemInstanceIdValue.IsValid() && !UnlockedWithItemInstanceIdValue->IsNull())
      {
          FString TmpValue;
          if (UnlockedWithItemInstanceIdValue->TryGetString(TmpValue)) { UnlockedWithItemInstanceId = TmpValue; }
      }
  
      const TSharedPtr<FJsonObject>* VirtualCurrencyObject;
      if (obj->TryGetObjectField(TEXT("VirtualCurrency"), VirtualCurrencyObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*VirtualCurrencyObject)->Values); It; ++It)
          {
              uint32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              VirtualCurrency.Add(It.Key(), TmpValue);
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdateAvatarUrlRequest::~FUpdateAvatarUrlRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdateAvatarUrlRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("ImageUrl")); writer->WriteValue(ImageUrl);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdateAvatarUrlRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> ImageUrlValue = obj->TryGetField(TEXT("ImageUrl"));
      if (ImageUrlValue.IsValid() && !ImageUrlValue->IsNull())
      {
          FString TmpValue;
          if (ImageUrlValue->TryGetString(TmpValue)) { ImageUrl = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdateCharacterDataRequest::~FUpdateCharacterDataRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdateCharacterDataRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId);
  
      if (Data.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Data"));
          for (TMap<FString, FString>::TConstIterator It(Data); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      if (KeysToRemove.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("KeysToRemove"));
          for (const FString& item : KeysToRemove)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (Permission.notNull()) { writer->WriteIdentifierPrefix(TEXT("Permission")); writeUserDataPermissionEnumJSON(Permission, writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdateCharacterDataRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonObject>* DataObject;
      if (obj->TryGetObjectField(TEXT("Data"), DataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*DataObject)->Values); It; ++It)
          {
              Data.Add(It.Key(), It.Value()->AsString());
          }
      }
  
      obj->TryGetStringArrayField(TEXT("KeysToRemove"), KeysToRemove);
  
      Permission = readUserDataPermissionFromValue(obj->TryGetField(TEXT("Permission")));
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdateCharacterDataResult::~FUpdateCharacterDataResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdateCharacterDataResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("DataVersion")); writer->WriteValue(static_cast<int64>(DataVersion));
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdateCharacterDataResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DataVersionValue = obj->TryGetField(TEXT("DataVersion"));
      if (DataVersionValue.IsValid() && !DataVersionValue->IsNull())
      {
          uint32 TmpValue;
          if (DataVersionValue->TryGetNumber(TmpValue)) { DataVersion = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdateCharacterStatisticsRequest::~FUpdateCharacterStatisticsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdateCharacterStatisticsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId);
  
      if (CharacterStatistics.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("CharacterStatistics"));
          for (TMap<FString, int32>::TConstIterator It(CharacterStatistics); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdateCharacterStatisticsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonObject>* CharacterStatisticsObject;
      if (obj->TryGetObjectField(TEXT("CharacterStatistics"), CharacterStatisticsObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*CharacterStatisticsObject)->Values); It; ++It)
          {
              int32 TmpValue; It.Value()->TryGetNumber(TmpValue);
              CharacterStatistics.Add(It.Key(), TmpValue);
          }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdateCharacterStatisticsResult::~FUpdateCharacterStatisticsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdateCharacterStatisticsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdateCharacterStatisticsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdatePlayerStatisticsRequest::~FUpdatePlayerStatisticsRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdatePlayerStatisticsRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteArrayStart(TEXT("Statistics"));
      for (const FStatisticUpdate& item : Statistics)
          item.writeJSON(writer);
      writer->WriteArrayEnd();
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdatePlayerStatisticsRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&StatisticsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Statistics"));
      for (int32 Idx = 0; Idx < StatisticsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = StatisticsArray[Idx];
          Statistics.Add(FStatisticUpdate(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdatePlayerStatisticsResult::~FUpdatePlayerStatisticsResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdatePlayerStatisticsResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdatePlayerStatisticsResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdateSharedGroupDataRequest::~FUpdateSharedGroupDataRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdateSharedGroupDataRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Data"));
          for (TMap<FString, FString>::TConstIterator It(Data); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      if (KeysToRemove.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("KeysToRemove"));
          for (const FString& item : KeysToRemove)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (Permission.notNull()) { writer->WriteIdentifierPrefix(TEXT("Permission")); writeUserDataPermissionEnumJSON(Permission, writer); }
  
      writer->WriteIdentifierPrefix(TEXT("SharedGroupId")); writer->WriteValue(SharedGroupId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdateSharedGroupDataRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* DataObject;
      if (obj->TryGetObjectField(TEXT("Data"), DataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*DataObject)->Values); It; ++It)
          {
              Data.Add(It.Key(), It.Value()->AsString());
          }
      }
  
      obj->TryGetStringArrayField(TEXT("KeysToRemove"), KeysToRemove);
  
      Permission = readUserDataPermissionFromValue(obj->TryGetField(TEXT("Permission")));
  
      const TSharedPtr<FJsonValue> SharedGroupIdValue = obj->TryGetField(TEXT("SharedGroupId"));
      if (SharedGroupIdValue.IsValid() && !SharedGroupIdValue->IsNull())
      {
          FString TmpValue;
          if (SharedGroupIdValue->TryGetString(TmpValue)) { SharedGroupId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdateSharedGroupDataResult::~FUpdateSharedGroupDataResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdateSharedGroupDataResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdateSharedGroupDataResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdateUserDataRequest::~FUpdateUserDataRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdateUserDataRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Data.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Data"));
          for (TMap<FString, FString>::TConstIterator It(Data); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              writer->WriteValue((*It).Value);
          }
          writer->WriteObjectEnd();
      }
  
      if (KeysToRemove.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("KeysToRemove"));
          for (const FString& item : KeysToRemove)
              writer->WriteValue(item);
          writer->WriteArrayEnd();
      }
  
  
      if (Permission.notNull()) { writer->WriteIdentifierPrefix(TEXT("Permission")); writeUserDataPermissionEnumJSON(Permission, writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdateUserDataRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* DataObject;
      if (obj->TryGetObjectField(TEXT("Data"), DataObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*DataObject)->Values); It; ++It)
          {
              Data.Add(It.Key(), It.Value()->AsString());
          }
      }
  
      obj->TryGetStringArrayField(TEXT("KeysToRemove"), KeysToRemove);
  
      Permission = readUserDataPermissionFromValue(obj->TryGetField(TEXT("Permission")));
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdateUserDataResult::~FUpdateUserDataResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdateUserDataResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("DataVersion")); writer->WriteValue(static_cast<int64>(DataVersion));
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdateUserDataResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DataVersionValue = obj->TryGetField(TEXT("DataVersion"));
      if (DataVersionValue.IsValid() && !DataVersionValue->IsNull())
      {
          uint32 TmpValue;
          if (DataVersionValue->TryGetNumber(TmpValue)) { DataVersion = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdateUserTitleDisplayNameRequest::~FUpdateUserTitleDisplayNameRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdateUserTitleDisplayNameRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      writer->WriteIdentifierPrefix(TEXT("DisplayName")); writer->WriteValue(DisplayName);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdateUserTitleDisplayNameRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DisplayNameValue = obj->TryGetField(TEXT("DisplayName"));
      if (DisplayNameValue.IsValid() && !DisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (DisplayNameValue->TryGetString(TmpValue)) { DisplayName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FUpdateUserTitleDisplayNameResult::~FUpdateUserTitleDisplayNameResult()
  {
  
  }
  
  void PlayFab::ClientModels::FUpdateUserTitleDisplayNameResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (DisplayName.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("DisplayName")); writer->WriteValue(DisplayName); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FUpdateUserTitleDisplayNameResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> DisplayNameValue = obj->TryGetField(TEXT("DisplayName"));
      if (DisplayNameValue.IsValid() && !DisplayNameValue->IsNull())
      {
          FString TmpValue;
          if (DisplayNameValue->TryGetString(TmpValue)) { DisplayName = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FValidateAmazonReceiptRequest::~FValidateAmazonReceiptRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FValidateAmazonReceiptRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      writer->WriteIdentifierPrefix(TEXT("CurrencyCode")); writer->WriteValue(CurrencyCode);
  
      writer->WriteIdentifierPrefix(TEXT("PurchasePrice")); writer->WriteValue(PurchasePrice);
  
      writer->WriteIdentifierPrefix(TEXT("ReceiptId")); writer->WriteValue(ReceiptId);
  
      writer->WriteIdentifierPrefix(TEXT("UserId")); writer->WriteValue(UserId);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FValidateAmazonReceiptRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CurrencyCodeValue = obj->TryGetField(TEXT("CurrencyCode"));
      if (CurrencyCodeValue.IsValid() && !CurrencyCodeValue->IsNull())
      {
          FString TmpValue;
          if (CurrencyCodeValue->TryGetString(TmpValue)) { CurrencyCode = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PurchasePriceValue = obj->TryGetField(TEXT("PurchasePrice"));
      if (PurchasePriceValue.IsValid() && !PurchasePriceValue->IsNull())
      {
          int32 TmpValue;
          if (PurchasePriceValue->TryGetNumber(TmpValue)) { PurchasePrice = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ReceiptIdValue = obj->TryGetField(TEXT("ReceiptId"));
      if (ReceiptIdValue.IsValid() && !ReceiptIdValue->IsNull())
      {
          FString TmpValue;
          if (ReceiptIdValue->TryGetString(TmpValue)) { ReceiptId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> UserIdValue = obj->TryGetField(TEXT("UserId"));
      if (UserIdValue.IsValid() && !UserIdValue->IsNull())
      {
          FString TmpValue;
          if (UserIdValue->TryGetString(TmpValue)) { UserId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FValidateAmazonReceiptResult::~FValidateAmazonReceiptResult()
  {
  
  }
  
  void PlayFab::ClientModels::FValidateAmazonReceiptResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Fulfillments.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Fulfillments"));
          for (const FPurchaseReceiptFulfillment& item : Fulfillments)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FValidateAmazonReceiptResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&FulfillmentsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Fulfillments"));
      for (int32 Idx = 0; Idx < FulfillmentsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = FulfillmentsArray[Idx];
          Fulfillments.Add(FPurchaseReceiptFulfillment(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FValidateGooglePlayPurchaseRequest::~FValidateGooglePlayPurchaseRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FValidateGooglePlayPurchaseRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      if (CurrencyCode.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CurrencyCode")); writer->WriteValue(CurrencyCode); }
  
      if (PurchasePrice.notNull()) { writer->WriteIdentifierPrefix(TEXT("PurchasePrice")); writer->WriteValue(static_cast<int64>(PurchasePrice)); }
  
      writer->WriteIdentifierPrefix(TEXT("ReceiptJson")); writer->WriteValue(ReceiptJson);
  
      writer->WriteIdentifierPrefix(TEXT("Signature")); writer->WriteValue(Signature);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FValidateGooglePlayPurchaseRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CurrencyCodeValue = obj->TryGetField(TEXT("CurrencyCode"));
      if (CurrencyCodeValue.IsValid() && !CurrencyCodeValue->IsNull())
      {
          FString TmpValue;
          if (CurrencyCodeValue->TryGetString(TmpValue)) { CurrencyCode = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PurchasePriceValue = obj->TryGetField(TEXT("PurchasePrice"));
      if (PurchasePriceValue.IsValid() && !PurchasePriceValue->IsNull())
      {
          uint32 TmpValue;
          if (PurchasePriceValue->TryGetNumber(TmpValue)) { PurchasePrice = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ReceiptJsonValue = obj->TryGetField(TEXT("ReceiptJson"));
      if (ReceiptJsonValue.IsValid() && !ReceiptJsonValue->IsNull())
      {
          FString TmpValue;
          if (ReceiptJsonValue->TryGetString(TmpValue)) { ReceiptJson = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> SignatureValue = obj->TryGetField(TEXT("Signature"));
      if (SignatureValue.IsValid() && !SignatureValue->IsNull())
      {
          FString TmpValue;
          if (SignatureValue->TryGetString(TmpValue)) { Signature = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FValidateGooglePlayPurchaseResult::~FValidateGooglePlayPurchaseResult()
  {
  
  }
  
  void PlayFab::ClientModels::FValidateGooglePlayPurchaseResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Fulfillments.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Fulfillments"));
          for (const FPurchaseReceiptFulfillment& item : Fulfillments)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FValidateGooglePlayPurchaseResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&FulfillmentsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Fulfillments"));
      for (int32 Idx = 0; Idx < FulfillmentsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = FulfillmentsArray[Idx];
          Fulfillments.Add(FPurchaseReceiptFulfillment(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FValidateIOSReceiptRequest::~FValidateIOSReceiptRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FValidateIOSReceiptRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      writer->WriteIdentifierPrefix(TEXT("CurrencyCode")); writer->WriteValue(CurrencyCode);
  
      writer->WriteIdentifierPrefix(TEXT("PurchasePrice")); writer->WriteValue(PurchasePrice);
  
      writer->WriteIdentifierPrefix(TEXT("ReceiptData")); writer->WriteValue(ReceiptData);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FValidateIOSReceiptRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CurrencyCodeValue = obj->TryGetField(TEXT("CurrencyCode"));
      if (CurrencyCodeValue.IsValid() && !CurrencyCodeValue->IsNull())
      {
          FString TmpValue;
          if (CurrencyCodeValue->TryGetString(TmpValue)) { CurrencyCode = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PurchasePriceValue = obj->TryGetField(TEXT("PurchasePrice"));
      if (PurchasePriceValue.IsValid() && !PurchasePriceValue->IsNull())
      {
          int32 TmpValue;
          if (PurchasePriceValue->TryGetNumber(TmpValue)) { PurchasePrice = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ReceiptDataValue = obj->TryGetField(TEXT("ReceiptData"));
      if (ReceiptDataValue.IsValid() && !ReceiptDataValue->IsNull())
      {
          FString TmpValue;
          if (ReceiptDataValue->TryGetString(TmpValue)) { ReceiptData = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FValidateIOSReceiptResult::~FValidateIOSReceiptResult()
  {
  
  }
  
  void PlayFab::ClientModels::FValidateIOSReceiptResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Fulfillments.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Fulfillments"));
          for (const FPurchaseReceiptFulfillment& item : Fulfillments)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FValidateIOSReceiptResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&FulfillmentsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Fulfillments"));
      for (int32 Idx = 0; Idx < FulfillmentsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = FulfillmentsArray[Idx];
          Fulfillments.Add(FPurchaseReceiptFulfillment(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FValidateWindowsReceiptRequest::~FValidateWindowsReceiptRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FValidateWindowsReceiptRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (CatalogVersion.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("CatalogVersion")); writer->WriteValue(CatalogVersion); }
  
      writer->WriteIdentifierPrefix(TEXT("CurrencyCode")); writer->WriteValue(CurrencyCode);
  
      writer->WriteIdentifierPrefix(TEXT("PurchasePrice")); writer->WriteValue(static_cast<int64>(PurchasePrice));
  
      writer->WriteIdentifierPrefix(TEXT("Receipt")); writer->WriteValue(Receipt);
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FValidateWindowsReceiptRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> CatalogVersionValue = obj->TryGetField(TEXT("CatalogVersion"));
      if (CatalogVersionValue.IsValid() && !CatalogVersionValue->IsNull())
      {
          FString TmpValue;
          if (CatalogVersionValue->TryGetString(TmpValue)) { CatalogVersion = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> CurrencyCodeValue = obj->TryGetField(TEXT("CurrencyCode"));
      if (CurrencyCodeValue.IsValid() && !CurrencyCodeValue->IsNull())
      {
          FString TmpValue;
          if (CurrencyCodeValue->TryGetString(TmpValue)) { CurrencyCode = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> PurchasePriceValue = obj->TryGetField(TEXT("PurchasePrice"));
      if (PurchasePriceValue.IsValid() && !PurchasePriceValue->IsNull())
      {
          uint32 TmpValue;
          if (PurchasePriceValue->TryGetNumber(TmpValue)) { PurchasePrice = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> ReceiptValue = obj->TryGetField(TEXT("Receipt"));
      if (ReceiptValue.IsValid() && !ReceiptValue->IsNull())
      {
          FString TmpValue;
          if (ReceiptValue->TryGetString(TmpValue)) { Receipt = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FValidateWindowsReceiptResult::~FValidateWindowsReceiptResult()
  {
  
  }
  
  void PlayFab::ClientModels::FValidateWindowsReceiptResult::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Fulfillments.Num() != 0)
      {
          writer->WriteArrayStart(TEXT("Fulfillments"));
          for (const FPurchaseReceiptFulfillment& item : Fulfillments)
              item.writeJSON(writer);
          writer->WriteArrayEnd();
      }
  
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FValidateWindowsReceiptResult::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TArray<TSharedPtr<FJsonValue>>&FulfillmentsArray = FPlayFabJsonHelpers::ReadArray(obj, TEXT("Fulfillments"));
      for (int32 Idx = 0; Idx < FulfillmentsArray.Num(); Idx++)
      {
          TSharedPtr<FJsonValue> CurrentItem = FulfillmentsArray[Idx];
          Fulfillments.Add(FPurchaseReceiptFulfillment(CurrentItem->AsObject()));
      }
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FWriteClientCharacterEventRequest::~FWriteClientCharacterEventRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FWriteClientCharacterEventRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Body.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Body"));
          for (TMap<FString, FJsonKeeper>::TConstIterator It(Body); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteIdentifierPrefix(TEXT("CharacterId")); writer->WriteValue(CharacterId);
  
      writer->WriteIdentifierPrefix(TEXT("EventName")); writer->WriteValue(EventName);
  
      if (Timestamp.notNull()) { writer->WriteIdentifierPrefix(TEXT("Timestamp")); writeDatetime(Timestamp, writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FWriteClientCharacterEventRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* BodyObject;
      if (obj->TryGetObjectField(TEXT("Body"), BodyObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*BodyObject)->Values); It; ++It)
          {
              Body.Add(It.Key(), FJsonKeeper(It.Value()));
          }
      }
  
      const TSharedPtr<FJsonValue> CharacterIdValue = obj->TryGetField(TEXT("CharacterId"));
      if (CharacterIdValue.IsValid() && !CharacterIdValue->IsNull())
      {
          FString TmpValue;
          if (CharacterIdValue->TryGetString(TmpValue)) { CharacterId = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> EventNameValue = obj->TryGetField(TEXT("EventName"));
      if (EventNameValue.IsValid() && !EventNameValue->IsNull())
      {
          FString TmpValue;
          if (EventNameValue->TryGetString(TmpValue)) { EventName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TimestampValue = obj->TryGetField(TEXT("Timestamp"));
      if (TimestampValue.IsValid())
          Timestamp = readDatetime(TimestampValue);
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FWriteClientPlayerEventRequest::~FWriteClientPlayerEventRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FWriteClientPlayerEventRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Body.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Body"));
          for (TMap<FString, FJsonKeeper>::TConstIterator It(Body); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteIdentifierPrefix(TEXT("EventName")); writer->WriteValue(EventName);
  
      if (Timestamp.notNull()) { writer->WriteIdentifierPrefix(TEXT("Timestamp")); writeDatetime(Timestamp, writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FWriteClientPlayerEventRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* BodyObject;
      if (obj->TryGetObjectField(TEXT("Body"), BodyObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*BodyObject)->Values); It; ++It)
          {
              Body.Add(It.Key(), FJsonKeeper(It.Value()));
          }
      }
  
      const TSharedPtr<FJsonValue> EventNameValue = obj->TryGetField(TEXT("EventName"));
      if (EventNameValue.IsValid() && !EventNameValue->IsNull())
      {
          FString TmpValue;
          if (EventNameValue->TryGetString(TmpValue)) { EventName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TimestampValue = obj->TryGetField(TEXT("Timestamp"));
      if (TimestampValue.IsValid())
          Timestamp = readDatetime(TimestampValue);
  
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FWriteEventResponse::~FWriteEventResponse()
  {
  
  }
  
  void PlayFab::ClientModels::FWriteEventResponse::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (EventId.IsEmpty() == false) { writer->WriteIdentifierPrefix(TEXT("EventId")); writer->WriteValue(EventId); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FWriteEventResponse::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonValue> EventIdValue = obj->TryGetField(TEXT("EventId"));
      if (EventIdValue.IsValid() && !EventIdValue->IsNull())
      {
          FString TmpValue;
          if (EventIdValue->TryGetString(TmpValue)) { EventId = TmpValue; }
      }
  
      return HasSucceeded;
  }
  
  PlayFab::ClientModels::FWriteTitleEventRequest::~FWriteTitleEventRequest()
  {
  
  }
  
  void PlayFab::ClientModels::FWriteTitleEventRequest::writeJSON(JsonWriter& writer) const
  {
      writer->WriteObjectStart();
  
      if (Body.Num() != 0)
      {
          writer->WriteObjectStart(TEXT("Body"));
          for (TMap<FString, FJsonKeeper>::TConstIterator It(Body); It; ++It)
          {
              writer->WriteIdentifierPrefix((*It).Key);
              (*It).Value.writeJSON(writer);
          }
          writer->WriteObjectEnd();
      }
  
      writer->WriteIdentifierPrefix(TEXT("EventName")); writer->WriteValue(EventName);
  
      if (Timestamp.notNull()) { writer->WriteIdentifierPrefix(TEXT("Timestamp")); writeDatetime(Timestamp, writer); }
  
      writer->WriteObjectEnd();
  }
  
  bool PlayFab::ClientModels::FWriteTitleEventRequest::readFromValue(const TSharedPtr<FJsonObject>& obj)
  {
      bool HasSucceeded = true;
  
      const TSharedPtr<FJsonObject>* BodyObject;
      if (obj->TryGetObjectField(TEXT("Body"), BodyObject))
      {
          for (TMap<FString, TSharedPtr<FJsonValue>>::TConstIterator It((*BodyObject)->Values); It; ++It)
          {
              Body.Add(It.Key(), FJsonKeeper(It.Value()));
          }
      }
  
      const TSharedPtr<FJsonValue> EventNameValue = obj->TryGetField(TEXT("EventName"));
      if (EventNameValue.IsValid() && !EventNameValue->IsNull())
      {
          FString TmpValue;
          if (EventNameValue->TryGetString(TmpValue)) { EventName = TmpValue; }
      }
  
      const TSharedPtr<FJsonValue> TimestampValue = obj->TryGetField(TEXT("Timestamp"));
      if (TimestampValue.IsValid())
          Timestamp = readDatetime(TimestampValue);
  
  
      return HasSucceeded;
  }
  
  