MinFt/Client/LocalPackages/asap.playfab.async/Runtime/Gen/PlayFabClientAsyncAPI.cs

#if !DISABLE_PLAYFABCLIENT_API && !DISABLE_PLAYFAB_STATIC_API
using System.Threading.Tasks;
using PlayFab;
using UnityEngine;
using PlayFab.ClientModels;

namespace asap.playfab.async
{
    //generated file, do not modify
    public static partial class PlayFabClientAsyncAPI
    {

        public static Task<AcceptTradeResponse> AcceptTradeAsync(AcceptTradeRequest request)
        {
            var task = new TaskCompletionSource<AcceptTradeResponse>();
            PlayFabClientAPI.AcceptTrade(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<AddFriendResult> AddFriendAsync(AddFriendRequest request)
        {
            var task = new TaskCompletionSource<AddFriendResult>();
            PlayFabClientAPI.AddFriend(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<AddGenericIDResult> AddGenericIDAsync(AddGenericIDRequest request)
        {
            var task = new TaskCompletionSource<AddGenericIDResult>();
            PlayFabClientAPI.AddGenericID(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<AddOrUpdateContactEmailResult> AddOrUpdateContactEmailAsync(AddOrUpdateContactEmailRequest request)
        {
            var task = new TaskCompletionSource<AddOrUpdateContactEmailResult>();
            PlayFabClientAPI.AddOrUpdateContactEmail(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<AddSharedGroupMembersResult> AddSharedGroupMembersAsync(AddSharedGroupMembersRequest request)
        {
            var task = new TaskCompletionSource<AddSharedGroupMembersResult>();
            PlayFabClientAPI.AddSharedGroupMembers(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<AddUsernamePasswordResult> AddUsernamePasswordAsync(AddUsernamePasswordRequest request)
        {
            var task = new TaskCompletionSource<AddUsernamePasswordResult>();
            PlayFabClientAPI.AddUsernamePassword(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ModifyUserVirtualCurrencyResult> AddUserVirtualCurrencyAsync(AddUserVirtualCurrencyRequest request)
        {
            var task = new TaskCompletionSource<ModifyUserVirtualCurrencyResult>();
            PlayFabClientAPI.AddUserVirtualCurrency(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<AndroidDevicePushNotificationRegistrationResult> AndroidDevicePushNotificationRegistrationAsync(AndroidDevicePushNotificationRegistrationRequest request)
        {
            var task = new TaskCompletionSource<AndroidDevicePushNotificationRegistrationResult>();
            PlayFabClientAPI.AndroidDevicePushNotificationRegistration(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<AttributeInstallResult> AttributeInstallAsync(AttributeInstallRequest request)
        {
            var task = new TaskCompletionSource<AttributeInstallResult>();
            PlayFabClientAPI.AttributeInstall(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<CancelTradeResponse> CancelTradeAsync(CancelTradeRequest request)
        {
            var task = new TaskCompletionSource<CancelTradeResponse>();
            PlayFabClientAPI.CancelTrade(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ConfirmPurchaseResult> ConfirmPurchaseAsync(ConfirmPurchaseRequest request)
        {
            var task = new TaskCompletionSource<ConfirmPurchaseResult>();
            PlayFabClientAPI.ConfirmPurchase(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ConsumeItemResult> ConsumeItemAsync(ConsumeItemRequest request)
        {
            var task = new TaskCompletionSource<ConsumeItemResult>();
            PlayFabClientAPI.ConsumeItem(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ConsumeMicrosoftStoreEntitlementsResponse> ConsumeMicrosoftStoreEntitlementsAsync(ConsumeMicrosoftStoreEntitlementsRequest request)
        {
            var task = new TaskCompletionSource<ConsumeMicrosoftStoreEntitlementsResponse>();
            PlayFabClientAPI.ConsumeMicrosoftStoreEntitlements(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ConsumePS5EntitlementsResult> ConsumePS5EntitlementsAsync(ConsumePS5EntitlementsRequest request)
        {
            var task = new TaskCompletionSource<ConsumePS5EntitlementsResult>();
            PlayFabClientAPI.ConsumePS5Entitlements(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ConsumePSNEntitlementsResult> ConsumePSNEntitlementsAsync(ConsumePSNEntitlementsRequest request)
        {
            var task = new TaskCompletionSource<ConsumePSNEntitlementsResult>();
            PlayFabClientAPI.ConsumePSNEntitlements(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ConsumeXboxEntitlementsResult> ConsumeXboxEntitlementsAsync(ConsumeXboxEntitlementsRequest request)
        {
            var task = new TaskCompletionSource<ConsumeXboxEntitlementsResult>();
            PlayFabClientAPI.ConsumeXboxEntitlements(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<CreateSharedGroupResult> CreateSharedGroupAsync(CreateSharedGroupRequest request)
        {
            var task = new TaskCompletionSource<CreateSharedGroupResult>();
            PlayFabClientAPI.CreateSharedGroup(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ExecuteCloudScriptResult> ExecuteCloudScriptAsync(ExecuteCloudScriptRequest request)
        {
            var task = new TaskCompletionSource<ExecuteCloudScriptResult>();
            PlayFabClientAPI.ExecuteCloudScript(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetAccountInfoResult> GetAccountInfoAsync(GetAccountInfoRequest request)
        {
            var task = new TaskCompletionSource<GetAccountInfoResult>();
            PlayFabClientAPI.GetAccountInfo(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetAdPlacementsResult> GetAdPlacementsAsync(GetAdPlacementsRequest request)
        {
            var task = new TaskCompletionSource<GetAdPlacementsResult>();
            PlayFabClientAPI.GetAdPlacements(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ListUsersCharactersResult> GetAllUsersCharactersAsync(ListUsersCharactersRequest request)
        {
            var task = new TaskCompletionSource<ListUsersCharactersResult>();
            PlayFabClientAPI.GetAllUsersCharacters(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetCatalogItemsResult> GetCatalogItemsAsync(GetCatalogItemsRequest request)
        {
            var task = new TaskCompletionSource<GetCatalogItemsResult>();
            PlayFabClientAPI.GetCatalogItems(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetCharacterDataResult> GetCharacterDataAsync(GetCharacterDataRequest request)
        {
            var task = new TaskCompletionSource<GetCharacterDataResult>();
            PlayFabClientAPI.GetCharacterData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetCharacterInventoryResult> GetCharacterInventoryAsync(GetCharacterInventoryRequest request)
        {
            var task = new TaskCompletionSource<GetCharacterInventoryResult>();
            PlayFabClientAPI.GetCharacterInventory(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetCharacterLeaderboardResult> GetCharacterLeaderboardAsync(GetCharacterLeaderboardRequest request)
        {
            var task = new TaskCompletionSource<GetCharacterLeaderboardResult>();
            PlayFabClientAPI.GetCharacterLeaderboard(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetCharacterDataResult> GetCharacterReadOnlyDataAsync(GetCharacterDataRequest request)
        {
            var task = new TaskCompletionSource<GetCharacterDataResult>();
            PlayFabClientAPI.GetCharacterReadOnlyData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetCharacterStatisticsResult> GetCharacterStatisticsAsync(GetCharacterStatisticsRequest request)
        {
            var task = new TaskCompletionSource<GetCharacterStatisticsResult>();
            PlayFabClientAPI.GetCharacterStatistics(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetContentDownloadUrlResult> GetContentDownloadUrlAsync(GetContentDownloadUrlRequest request)
        {
            var task = new TaskCompletionSource<GetContentDownloadUrlResult>();
            PlayFabClientAPI.GetContentDownloadUrl(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetLeaderboardResult> GetFriendLeaderboardAsync(GetFriendLeaderboardRequest request)
        {
            var task = new TaskCompletionSource<GetLeaderboardResult>();
            PlayFabClientAPI.GetFriendLeaderboard(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetFriendLeaderboardAroundPlayerResult> GetFriendLeaderboardAroundPlayerAsync(GetFriendLeaderboardAroundPlayerRequest request)
        {
            var task = new TaskCompletionSource<GetFriendLeaderboardAroundPlayerResult>();
            PlayFabClientAPI.GetFriendLeaderboardAroundPlayer(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetFriendsListResult> GetFriendsListAsync(GetFriendsListRequest request)
        {
            var task = new TaskCompletionSource<GetFriendsListResult>();
            PlayFabClientAPI.GetFriendsList(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetLeaderboardResult> GetLeaderboardAsync(GetLeaderboardRequest request)
        {
            var task = new TaskCompletionSource<GetLeaderboardResult>();
            PlayFabClientAPI.GetLeaderboard(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetLeaderboardAroundCharacterResult> GetLeaderboardAroundCharacterAsync(GetLeaderboardAroundCharacterRequest request)
        {
            var task = new TaskCompletionSource<GetLeaderboardAroundCharacterResult>();
            PlayFabClientAPI.GetLeaderboardAroundCharacter(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetLeaderboardAroundPlayerResult> GetLeaderboardAroundPlayerAsync(GetLeaderboardAroundPlayerRequest request)
        {
            var task = new TaskCompletionSource<GetLeaderboardAroundPlayerResult>();
            PlayFabClientAPI.GetLeaderboardAroundPlayer(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetLeaderboardForUsersCharactersResult> GetLeaderboardForUserCharactersAsync(GetLeaderboardForUsersCharactersRequest request)
        {
            var task = new TaskCompletionSource<GetLeaderboardForUsersCharactersResult>();
            PlayFabClientAPI.GetLeaderboardForUserCharacters(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPaymentTokenResult> GetPaymentTokenAsync(GetPaymentTokenRequest request)
        {
            var task = new TaskCompletionSource<GetPaymentTokenResult>();
            PlayFabClientAPI.GetPaymentToken(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPhotonAuthenticationTokenResult> GetPhotonAuthenticationTokenAsync(GetPhotonAuthenticationTokenRequest request)
        {
            var task = new TaskCompletionSource<GetPhotonAuthenticationTokenResult>();
            PlayFabClientAPI.GetPhotonAuthenticationToken(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayerCombinedInfoResult> GetPlayerCombinedInfoAsync(GetPlayerCombinedInfoRequest request)
        {
            var task = new TaskCompletionSource<GetPlayerCombinedInfoResult>();
            PlayFabClientAPI.GetPlayerCombinedInfo(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayerProfileResult> GetPlayerProfileAsync(GetPlayerProfileRequest request)
        {
            var task = new TaskCompletionSource<GetPlayerProfileResult>();
            PlayFabClientAPI.GetPlayerProfile(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayerSegmentsResult> GetPlayerSegmentsAsync(GetPlayerSegmentsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayerSegmentsResult>();
            PlayFabClientAPI.GetPlayerSegments(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayerStatisticsResult> GetPlayerStatisticsAsync(GetPlayerStatisticsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayerStatisticsResult>();
            PlayFabClientAPI.GetPlayerStatistics(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayerStatisticVersionsResult> GetPlayerStatisticVersionsAsync(GetPlayerStatisticVersionsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayerStatisticVersionsResult>();
            PlayFabClientAPI.GetPlayerStatisticVersions(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayerTagsResult> GetPlayerTagsAsync(GetPlayerTagsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayerTagsResult>();
            PlayFabClientAPI.GetPlayerTags(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayerTradesResponse> GetPlayerTradesAsync(GetPlayerTradesRequest request)
        {
            var task = new TaskCompletionSource<GetPlayerTradesResponse>();
            PlayFabClientAPI.GetPlayerTrades(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromFacebookIDsResult> GetPlayFabIDsFromFacebookIDsAsync(GetPlayFabIDsFromFacebookIDsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromFacebookIDsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromFacebookIDs(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromFacebookInstantGamesIdsResult> GetPlayFabIDsFromFacebookInstantGamesIdsAsync(GetPlayFabIDsFromFacebookInstantGamesIdsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromFacebookInstantGamesIdsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromFacebookInstantGamesIds(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromGameCenterIDsResult> GetPlayFabIDsFromGameCenterIDsAsync(GetPlayFabIDsFromGameCenterIDsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromGameCenterIDsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromGameCenterIDs(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromGenericIDsResult> GetPlayFabIDsFromGenericIDsAsync(GetPlayFabIDsFromGenericIDsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromGenericIDsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromGenericIDs(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromGoogleIDsResult> GetPlayFabIDsFromGoogleIDsAsync(GetPlayFabIDsFromGoogleIDsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromGoogleIDsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromGoogleIDs(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromGooglePlayGamesPlayerIDsResult> GetPlayFabIDsFromGooglePlayGamesPlayerIDsAsync(GetPlayFabIDsFromGooglePlayGamesPlayerIDsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromGooglePlayGamesPlayerIDsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromGooglePlayGamesPlayerIDs(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromKongregateIDsResult> GetPlayFabIDsFromKongregateIDsAsync(GetPlayFabIDsFromKongregateIDsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromKongregateIDsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromKongregateIDs(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromNintendoServiceAccountIdsResult> GetPlayFabIDsFromNintendoServiceAccountIdsAsync(GetPlayFabIDsFromNintendoServiceAccountIdsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromNintendoServiceAccountIdsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromNintendoServiceAccountIds(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromNintendoSwitchDeviceIdsResult> GetPlayFabIDsFromNintendoSwitchDeviceIdsAsync(GetPlayFabIDsFromNintendoSwitchDeviceIdsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromNintendoSwitchDeviceIdsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromNintendoSwitchDeviceIds(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromPSNAccountIDsResult> GetPlayFabIDsFromPSNAccountIDsAsync(GetPlayFabIDsFromPSNAccountIDsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromPSNAccountIDsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromPSNAccountIDs(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromSteamIDsResult> GetPlayFabIDsFromSteamIDsAsync(GetPlayFabIDsFromSteamIDsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromSteamIDsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromSteamIDs(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromTwitchIDsResult> GetPlayFabIDsFromTwitchIDsAsync(GetPlayFabIDsFromTwitchIDsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromTwitchIDsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromTwitchIDs(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPlayFabIDsFromXboxLiveIDsResult> GetPlayFabIDsFromXboxLiveIDsAsync(GetPlayFabIDsFromXboxLiveIDsRequest request)
        {
            var task = new TaskCompletionSource<GetPlayFabIDsFromXboxLiveIDsResult>();
            PlayFabClientAPI.GetPlayFabIDsFromXboxLiveIDs(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPublisherDataResult> GetPublisherDataAsync(GetPublisherDataRequest request)
        {
            var task = new TaskCompletionSource<GetPublisherDataResult>();
            PlayFabClientAPI.GetPublisherData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetPurchaseResult> GetPurchaseAsync(GetPurchaseRequest request)
        {
            var task = new TaskCompletionSource<GetPurchaseResult>();
            PlayFabClientAPI.GetPurchase(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetSharedGroupDataResult> GetSharedGroupDataAsync(GetSharedGroupDataRequest request)
        {
            var task = new TaskCompletionSource<GetSharedGroupDataResult>();
            PlayFabClientAPI.GetSharedGroupData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetStoreItemsResult> GetStoreItemsAsync(GetStoreItemsRequest request)
        {
            var task = new TaskCompletionSource<GetStoreItemsResult>();
            PlayFabClientAPI.GetStoreItems(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetTimeResult> GetTimeAsync(GetTimeRequest request)
        {
            var task = new TaskCompletionSource<GetTimeResult>();
            PlayFabClientAPI.GetTime(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetTitleDataResult> GetTitleDataAsync(GetTitleDataRequest request)
        {
            var task = new TaskCompletionSource<GetTitleDataResult>();
            PlayFabClientAPI.GetTitleData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetTitleNewsResult> GetTitleNewsAsync(GetTitleNewsRequest request)
        {
            var task = new TaskCompletionSource<GetTitleNewsResult>();
            PlayFabClientAPI.GetTitleNews(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetTitlePublicKeyResult> GetTitlePublicKeyAsync(GetTitlePublicKeyRequest request)
        {
            var task = new TaskCompletionSource<GetTitlePublicKeyResult>();
            PlayFabClientAPI.GetTitlePublicKey(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetTradeStatusResponse> GetTradeStatusAsync(GetTradeStatusRequest request)
        {
            var task = new TaskCompletionSource<GetTradeStatusResponse>();
            PlayFabClientAPI.GetTradeStatus(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetUserDataResult> GetUserDataAsync(GetUserDataRequest request)
        {
            var task = new TaskCompletionSource<GetUserDataResult>();
            PlayFabClientAPI.GetUserData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetUserInventoryResult> GetUserInventoryAsync(GetUserInventoryRequest request)
        {
            var task = new TaskCompletionSource<GetUserInventoryResult>();
            PlayFabClientAPI.GetUserInventory(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetUserDataResult> GetUserPublisherDataAsync(GetUserDataRequest request)
        {
            var task = new TaskCompletionSource<GetUserDataResult>();
            PlayFabClientAPI.GetUserPublisherData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetUserDataResult> GetUserPublisherReadOnlyDataAsync(GetUserDataRequest request)
        {
            var task = new TaskCompletionSource<GetUserDataResult>();
            PlayFabClientAPI.GetUserPublisherReadOnlyData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GetUserDataResult> GetUserReadOnlyDataAsync(GetUserDataRequest request)
        {
            var task = new TaskCompletionSource<GetUserDataResult>();
            PlayFabClientAPI.GetUserReadOnlyData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<GrantCharacterToUserResult> GrantCharacterToUserAsync(GrantCharacterToUserRequest request)
        {
            var task = new TaskCompletionSource<GrantCharacterToUserResult>();
            PlayFabClientAPI.GrantCharacterToUser(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkAndroidDeviceIDResult> LinkAndroidDeviceIDAsync(LinkAndroidDeviceIDRequest request)
        {
            var task = new TaskCompletionSource<LinkAndroidDeviceIDResult>();
            PlayFabClientAPI.LinkAndroidDeviceID(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<EmptyResult> LinkAppleAsync(LinkAppleRequest request)
        {
            var task = new TaskCompletionSource<EmptyResult>();
            PlayFabClientAPI.LinkApple(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkCustomIDResult> LinkCustomIDAsync(LinkCustomIDRequest request)
        {
            var task = new TaskCompletionSource<LinkCustomIDResult>();
            PlayFabClientAPI.LinkCustomID(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkFacebookAccountResult> LinkFacebookAccountAsync(LinkFacebookAccountRequest request)
        {
            var task = new TaskCompletionSource<LinkFacebookAccountResult>();
            PlayFabClientAPI.LinkFacebookAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkFacebookInstantGamesIdResult> LinkFacebookInstantGamesIdAsync(LinkFacebookInstantGamesIdRequest request)
        {
            var task = new TaskCompletionSource<LinkFacebookInstantGamesIdResult>();
            PlayFabClientAPI.LinkFacebookInstantGamesId(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkGameCenterAccountResult> LinkGameCenterAccountAsync(LinkGameCenterAccountRequest request)
        {
            var task = new TaskCompletionSource<LinkGameCenterAccountResult>();
            PlayFabClientAPI.LinkGameCenterAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkGoogleAccountResult> LinkGoogleAccountAsync(LinkGoogleAccountRequest request)
        {
            var task = new TaskCompletionSource<LinkGoogleAccountResult>();
            PlayFabClientAPI.LinkGoogleAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkGooglePlayGamesServicesAccountResult> LinkGooglePlayGamesServicesAccountAsync(LinkGooglePlayGamesServicesAccountRequest request)
        {
            var task = new TaskCompletionSource<LinkGooglePlayGamesServicesAccountResult>();
            PlayFabClientAPI.LinkGooglePlayGamesServicesAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkIOSDeviceIDResult> LinkIOSDeviceIDAsync(LinkIOSDeviceIDRequest request)
        {
            var task = new TaskCompletionSource<LinkIOSDeviceIDResult>();
            PlayFabClientAPI.LinkIOSDeviceID(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkKongregateAccountResult> LinkKongregateAsync(LinkKongregateAccountRequest request)
        {
            var task = new TaskCompletionSource<LinkKongregateAccountResult>();
            PlayFabClientAPI.LinkKongregate(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<EmptyResult> LinkNintendoServiceAccountAsync(LinkNintendoServiceAccountRequest request)
        {
            var task = new TaskCompletionSource<EmptyResult>();
            PlayFabClientAPI.LinkNintendoServiceAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkNintendoSwitchDeviceIdResult> LinkNintendoSwitchDeviceIdAsync(LinkNintendoSwitchDeviceIdRequest request)
        {
            var task = new TaskCompletionSource<LinkNintendoSwitchDeviceIdResult>();
            PlayFabClientAPI.LinkNintendoSwitchDeviceId(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<EmptyResult> LinkOpenIdConnectAsync(LinkOpenIdConnectRequest request)
        {
            var task = new TaskCompletionSource<EmptyResult>();
            PlayFabClientAPI.LinkOpenIdConnect(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkPSNAccountResult> LinkPSNAccountAsync(LinkPSNAccountRequest request)
        {
            var task = new TaskCompletionSource<LinkPSNAccountResult>();
            PlayFabClientAPI.LinkPSNAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkSteamAccountResult> LinkSteamAccountAsync(LinkSteamAccountRequest request)
        {
            var task = new TaskCompletionSource<LinkSteamAccountResult>();
            PlayFabClientAPI.LinkSteamAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkTwitchAccountResult> LinkTwitchAsync(LinkTwitchAccountRequest request)
        {
            var task = new TaskCompletionSource<LinkTwitchAccountResult>();
            PlayFabClientAPI.LinkTwitch(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LinkXboxAccountResult> LinkXboxAccountAsync(LinkXboxAccountRequest request)
        {
            var task = new TaskCompletionSource<LinkXboxAccountResult>();
            PlayFabClientAPI.LinkXboxAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithAndroidDeviceIDAsync(LoginWithAndroidDeviceIDRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithAndroidDeviceID(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithAppleAsync(LoginWithAppleRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithApple(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithCustomIDAsync(LoginWithCustomIDRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithCustomID(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithEmailAddressAsync(LoginWithEmailAddressRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithEmailAddress(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithFacebookAsync(LoginWithFacebookRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithFacebook(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithFacebookInstantGamesIdAsync(LoginWithFacebookInstantGamesIdRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithFacebookInstantGamesId(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithGameCenterAsync(LoginWithGameCenterRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithGameCenter(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithGoogleAccountAsync(LoginWithGoogleAccountRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithGoogleAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithGooglePlayGamesServicesAsync(LoginWithGooglePlayGamesServicesRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithGooglePlayGamesServices(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithIOSDeviceIDAsync(LoginWithIOSDeviceIDRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithIOSDeviceID(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithKongregateAsync(LoginWithKongregateRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithKongregate(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithNintendoServiceAccountAsync(LoginWithNintendoServiceAccountRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithNintendoServiceAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithNintendoSwitchDeviceIdAsync(LoginWithNintendoSwitchDeviceIdRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithNintendoSwitchDeviceId(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithOpenIdConnectAsync(LoginWithOpenIdConnectRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithOpenIdConnect(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithPlayFabAsync(LoginWithPlayFabRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithPlayFab(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithPSNAsync(LoginWithPSNRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithPSN(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithSteamAsync(LoginWithSteamRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithSteam(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithTwitchAsync(LoginWithTwitchRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithTwitch(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<LoginResult> LoginWithXboxAsync(LoginWithXboxRequest request)
        {
            var task = new TaskCompletionSource<LoginResult>();
            PlayFabClientAPI.LoginWithXbox(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<OpenTradeResponse> OpenTradeAsync(OpenTradeRequest request)
        {
            var task = new TaskCompletionSource<OpenTradeResponse>();
            PlayFabClientAPI.OpenTrade(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<PayForPurchaseResult> PayForPurchaseAsync(PayForPurchaseRequest request)
        {
            var task = new TaskCompletionSource<PayForPurchaseResult>();
            PlayFabClientAPI.PayForPurchase(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<PurchaseItemResult> PurchaseItemAsync(PurchaseItemRequest request)
        {
            var task = new TaskCompletionSource<PurchaseItemResult>();
            PlayFabClientAPI.PurchaseItem(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<RedeemCouponResult> RedeemCouponAsync(RedeemCouponRequest request)
        {
            var task = new TaskCompletionSource<RedeemCouponResult>();
            PlayFabClientAPI.RedeemCoupon(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<EmptyResponse> RefreshPSNAuthTokenAsync(RefreshPSNAuthTokenRequest request)
        {
            var task = new TaskCompletionSource<EmptyResponse>();
            PlayFabClientAPI.RefreshPSNAuthToken(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<RegisterForIOSPushNotificationResult> RegisterForIOSPushNotificationAsync(RegisterForIOSPushNotificationRequest request)
        {
            var task = new TaskCompletionSource<RegisterForIOSPushNotificationResult>();
            PlayFabClientAPI.RegisterForIOSPushNotification(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<RegisterPlayFabUserResult> RegisterPlayFabUserAsync(RegisterPlayFabUserRequest request)
        {
            var task = new TaskCompletionSource<RegisterPlayFabUserResult>();
            PlayFabClientAPI.RegisterPlayFabUser(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<RemoveContactEmailResult> RemoveContactEmailAsync(RemoveContactEmailRequest request)
        {
            var task = new TaskCompletionSource<RemoveContactEmailResult>();
            PlayFabClientAPI.RemoveContactEmail(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<RemoveFriendResult> RemoveFriendAsync(RemoveFriendRequest request)
        {
            var task = new TaskCompletionSource<RemoveFriendResult>();
            PlayFabClientAPI.RemoveFriend(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<RemoveGenericIDResult> RemoveGenericIDAsync(RemoveGenericIDRequest request)
        {
            var task = new TaskCompletionSource<RemoveGenericIDResult>();
            PlayFabClientAPI.RemoveGenericID(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<RemoveSharedGroupMembersResult> RemoveSharedGroupMembersAsync(RemoveSharedGroupMembersRequest request)
        {
            var task = new TaskCompletionSource<RemoveSharedGroupMembersResult>();
            PlayFabClientAPI.RemoveSharedGroupMembers(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ReportAdActivityResult> ReportAdActivityAsync(ReportAdActivityRequest request)
        {
            var task = new TaskCompletionSource<ReportAdActivityResult>();
            PlayFabClientAPI.ReportAdActivity(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<EmptyResponse> ReportDeviceInfoAsync(DeviceInfoRequest request)
        {
            var task = new TaskCompletionSource<EmptyResponse>();
            PlayFabClientAPI.ReportDeviceInfo(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ReportPlayerClientResult> ReportPlayerAsync(ReportPlayerClientRequest request)
        {
            var task = new TaskCompletionSource<ReportPlayerClientResult>();
            PlayFabClientAPI.ReportPlayer(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<RestoreIOSPurchasesResult> RestoreIOSPurchasesAsync(RestoreIOSPurchasesRequest request)
        {
            var task = new TaskCompletionSource<RestoreIOSPurchasesResult>();
            PlayFabClientAPI.RestoreIOSPurchases(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<RewardAdActivityResult> RewardAdActivityAsync(RewardAdActivityRequest request)
        {
            var task = new TaskCompletionSource<RewardAdActivityResult>();
            PlayFabClientAPI.RewardAdActivity(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<SendAccountRecoveryEmailResult> SendAccountRecoveryEmailAsync(SendAccountRecoveryEmailRequest request)
        {
            var task = new TaskCompletionSource<SendAccountRecoveryEmailResult>();
            PlayFabClientAPI.SendAccountRecoveryEmail(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<SetFriendTagsResult> SetFriendTagsAsync(SetFriendTagsRequest request)
        {
            var task = new TaskCompletionSource<SetFriendTagsResult>();
            PlayFabClientAPI.SetFriendTags(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<SetPlayerSecretResult> SetPlayerSecretAsync(SetPlayerSecretRequest request)
        {
            var task = new TaskCompletionSource<SetPlayerSecretResult>();
            PlayFabClientAPI.SetPlayerSecret(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<StartPurchaseResult> StartPurchaseAsync(StartPurchaseRequest request)
        {
            var task = new TaskCompletionSource<StartPurchaseResult>();
            PlayFabClientAPI.StartPurchase(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ModifyUserVirtualCurrencyResult> SubtractUserVirtualCurrencyAsync(SubtractUserVirtualCurrencyRequest request)
        {
            var task = new TaskCompletionSource<ModifyUserVirtualCurrencyResult>();
            PlayFabClientAPI.SubtractUserVirtualCurrency(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkAndroidDeviceIDResult> UnlinkAndroidDeviceIDAsync(UnlinkAndroidDeviceIDRequest request)
        {
            var task = new TaskCompletionSource<UnlinkAndroidDeviceIDResult>();
            PlayFabClientAPI.UnlinkAndroidDeviceID(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<EmptyResponse> UnlinkAppleAsync(UnlinkAppleRequest request)
        {
            var task = new TaskCompletionSource<EmptyResponse>();
            PlayFabClientAPI.UnlinkApple(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkCustomIDResult> UnlinkCustomIDAsync(UnlinkCustomIDRequest request)
        {
            var task = new TaskCompletionSource<UnlinkCustomIDResult>();
            PlayFabClientAPI.UnlinkCustomID(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkFacebookAccountResult> UnlinkFacebookAccountAsync(UnlinkFacebookAccountRequest request)
        {
            var task = new TaskCompletionSource<UnlinkFacebookAccountResult>();
            PlayFabClientAPI.UnlinkFacebookAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkFacebookInstantGamesIdResult> UnlinkFacebookInstantGamesIdAsync(UnlinkFacebookInstantGamesIdRequest request)
        {
            var task = new TaskCompletionSource<UnlinkFacebookInstantGamesIdResult>();
            PlayFabClientAPI.UnlinkFacebookInstantGamesId(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkGameCenterAccountResult> UnlinkGameCenterAccountAsync(UnlinkGameCenterAccountRequest request)
        {
            var task = new TaskCompletionSource<UnlinkGameCenterAccountResult>();
            PlayFabClientAPI.UnlinkGameCenterAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkGoogleAccountResult> UnlinkGoogleAccountAsync(UnlinkGoogleAccountRequest request)
        {
            var task = new TaskCompletionSource<UnlinkGoogleAccountResult>();
            PlayFabClientAPI.UnlinkGoogleAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkGooglePlayGamesServicesAccountResult> UnlinkGooglePlayGamesServicesAccountAsync(UnlinkGooglePlayGamesServicesAccountRequest request)
        {
            var task = new TaskCompletionSource<UnlinkGooglePlayGamesServicesAccountResult>();
            PlayFabClientAPI.UnlinkGooglePlayGamesServicesAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkIOSDeviceIDResult> UnlinkIOSDeviceIDAsync(UnlinkIOSDeviceIDRequest request)
        {
            var task = new TaskCompletionSource<UnlinkIOSDeviceIDResult>();
            PlayFabClientAPI.UnlinkIOSDeviceID(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkKongregateAccountResult> UnlinkKongregateAsync(UnlinkKongregateAccountRequest request)
        {
            var task = new TaskCompletionSource<UnlinkKongregateAccountResult>();
            PlayFabClientAPI.UnlinkKongregate(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<EmptyResponse> UnlinkNintendoServiceAccountAsync(UnlinkNintendoServiceAccountRequest request)
        {
            var task = new TaskCompletionSource<EmptyResponse>();
            PlayFabClientAPI.UnlinkNintendoServiceAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkNintendoSwitchDeviceIdResult> UnlinkNintendoSwitchDeviceIdAsync(UnlinkNintendoSwitchDeviceIdRequest request)
        {
            var task = new TaskCompletionSource<UnlinkNintendoSwitchDeviceIdResult>();
            PlayFabClientAPI.UnlinkNintendoSwitchDeviceId(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<EmptyResponse> UnlinkOpenIdConnectAsync(UnlinkOpenIdConnectRequest request)
        {
            var task = new TaskCompletionSource<EmptyResponse>();
            PlayFabClientAPI.UnlinkOpenIdConnect(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkPSNAccountResult> UnlinkPSNAccountAsync(UnlinkPSNAccountRequest request)
        {
            var task = new TaskCompletionSource<UnlinkPSNAccountResult>();
            PlayFabClientAPI.UnlinkPSNAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkSteamAccountResult> UnlinkSteamAccountAsync(UnlinkSteamAccountRequest request)
        {
            var task = new TaskCompletionSource<UnlinkSteamAccountResult>();
            PlayFabClientAPI.UnlinkSteamAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkTwitchAccountResult> UnlinkTwitchAsync(UnlinkTwitchAccountRequest request)
        {
            var task = new TaskCompletionSource<UnlinkTwitchAccountResult>();
            PlayFabClientAPI.UnlinkTwitch(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlinkXboxAccountResult> UnlinkXboxAccountAsync(UnlinkXboxAccountRequest request)
        {
            var task = new TaskCompletionSource<UnlinkXboxAccountResult>();
            PlayFabClientAPI.UnlinkXboxAccount(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlockContainerItemResult> UnlockContainerInstanceAsync(UnlockContainerInstanceRequest request)
        {
            var task = new TaskCompletionSource<UnlockContainerItemResult>();
            PlayFabClientAPI.UnlockContainerInstance(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UnlockContainerItemResult> UnlockContainerItemAsync(UnlockContainerItemRequest request)
        {
            var task = new TaskCompletionSource<UnlockContainerItemResult>();
            PlayFabClientAPI.UnlockContainerItem(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<EmptyResponse> UpdateAvatarUrlAsync(UpdateAvatarUrlRequest request)
        {
            var task = new TaskCompletionSource<EmptyResponse>();
            PlayFabClientAPI.UpdateAvatarUrl(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UpdateCharacterDataResult> UpdateCharacterDataAsync(UpdateCharacterDataRequest request)
        {
            var task = new TaskCompletionSource<UpdateCharacterDataResult>();
            PlayFabClientAPI.UpdateCharacterData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UpdateCharacterStatisticsResult> UpdateCharacterStatisticsAsync(UpdateCharacterStatisticsRequest request)
        {
            var task = new TaskCompletionSource<UpdateCharacterStatisticsResult>();
            PlayFabClientAPI.UpdateCharacterStatistics(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UpdatePlayerStatisticsResult> UpdatePlayerStatisticsAsync(UpdatePlayerStatisticsRequest request)
        {
            var task = new TaskCompletionSource<UpdatePlayerStatisticsResult>();
            PlayFabClientAPI.UpdatePlayerStatistics(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UpdateSharedGroupDataResult> UpdateSharedGroupDataAsync(UpdateSharedGroupDataRequest request)
        {
            var task = new TaskCompletionSource<UpdateSharedGroupDataResult>();
            PlayFabClientAPI.UpdateSharedGroupData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UpdateUserDataResult> UpdateUserDataAsync(UpdateUserDataRequest request)
        {
            var task = new TaskCompletionSource<UpdateUserDataResult>();
            PlayFabClientAPI.UpdateUserData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UpdateUserDataResult> UpdateUserPublisherDataAsync(UpdateUserDataRequest request)
        {
            var task = new TaskCompletionSource<UpdateUserDataResult>();
            PlayFabClientAPI.UpdateUserPublisherData(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<UpdateUserTitleDisplayNameResult> UpdateUserTitleDisplayNameAsync(UpdateUserTitleDisplayNameRequest request)
        {
            var task = new TaskCompletionSource<UpdateUserTitleDisplayNameResult>();
            PlayFabClientAPI.UpdateUserTitleDisplayName(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ValidateAmazonReceiptResult> ValidateAmazonIAPReceiptAsync(ValidateAmazonReceiptRequest request)
        {
            var task = new TaskCompletionSource<ValidateAmazonReceiptResult>();
            PlayFabClientAPI.ValidateAmazonIAPReceipt(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ValidateGooglePlayPurchaseResult> ValidateGooglePlayPurchaseAsync(ValidateGooglePlayPurchaseRequest request)
        {
            var task = new TaskCompletionSource<ValidateGooglePlayPurchaseResult>();
            PlayFabClientAPI.ValidateGooglePlayPurchase(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ValidateIOSReceiptResult> ValidateIOSReceiptAsync(ValidateIOSReceiptRequest request)
        {
            var task = new TaskCompletionSource<ValidateIOSReceiptResult>();
            PlayFabClientAPI.ValidateIOSReceipt(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<ValidateWindowsReceiptResult> ValidateWindowsStoreReceiptAsync(ValidateWindowsReceiptRequest request)
        {
            var task = new TaskCompletionSource<ValidateWindowsReceiptResult>();
            PlayFabClientAPI.ValidateWindowsStoreReceipt(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<WriteEventResponse> WriteCharacterEventAsync(WriteClientCharacterEventRequest request)
        {
            var task = new TaskCompletionSource<WriteEventResponse>();
            PlayFabClientAPI.WriteCharacterEvent(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<WriteEventResponse> WritePlayerEventAsync(WriteClientPlayerEventRequest request)
        {
            var task = new TaskCompletionSource<WriteEventResponse>();
            PlayFabClientAPI.WritePlayerEvent(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

        public static Task<WriteEventResponse> WriteTitleEventAsync(WriteTitleEventRequest request)
        {
            var task = new TaskCompletionSource<WriteEventResponse>();
            PlayFabClientAPI.WriteTitleEvent(request,
                result =>
                {
                    task.SetResult(result);
                },
                error =>
                {
                    Debug.LogError(error.GenerateErrorReport());
                    task.SetResult(null);
                });
            return task.Task;
        }

    }
}
#endif