/// <summary>
 /// Method reads all the global properties of the game
 /// </summary>
 /// <remarks>
 /// Service Name - GlobalApp
 /// Service Operation - ReadProperties
 /// </remarks>
 /// <param name="in_success">
 /// The success callback.
 /// </param>
 /// <param name="in_failure">
 /// The failure callback.
 /// </param>
 /// <param name="in_cbObject">
 /// The user object sent to the callback.
 /// </param>
 /// <returns> JSON describing the global properties:
 /// {
 ///   "status":200,
 ///   "data": {
 ///     "pName": {
 ///       "name": "pName",
 ///	      "description": "pValue",
 ///	      "value": "pDescription"
 ///	    }
 ///   }
 /// }
 /// </returns>
 public void ReadProperties(
     SuccessCallback in_success = null,
     FailureCallback in_failure = null,
     object in_cbObject = null)
 {
     ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
     ServerCall serverCall = new ServerCall(ServiceName.GlobalApp, ServiceOperation.ReadProperties, null, callback);
     m_brainCloudClientRef.SendRequest(serverCall);
 }

 /// <summary>
 /// Method returns all of the global statistics.
 /// </summary>
 /// <remarks>
 /// Service Name - GlobalStatistics
 /// Service Operation - Read
 /// </remarks>
 /// <param name="in_success">
 /// The success callback
 /// </param>
 /// <param name="in_failure">
 /// The failure callback
 /// </param>
 /// <param name="in_cbObject">
 /// The callback object
 /// </param>
 /// <returns> JSON describing the global statistics:
 /// {
 ///   "status":200,
 ///   "data":{
 ///     "statisticsExceptions":{
 ///     },
 ///     "statistics":{
 ///       "Level02_TimesBeaten":11,
 ///       "Level01_TimesBeaten":1,
 ///       "GameLogins":376,
 ///       "PlayersWhoLikePirateClothing":12
 ///     }
 ///   }
 /// }
 /// </returns>
 public void ReadAllGlobalStats(
     SuccessCallback in_success,
     FailureCallback in_failure,
     object in_cbObject = null)
 {
     ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
     ServerCall sc = new ServerCall(ServiceName.GlobalStatistics, ServiceOperation.Read, null, callback);
     m_brainCloudClientRef.SendRequest(sc);
 }

 public void AuthorizeTwitter(
     SuccessCallback in_success = null,
     FailureCallback in_failure = null,
     object in_cbObject = null)
 {
     ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
     ServerCall sc = new ServerCall(ServiceName.Event, ServiceOperation.Send, null, callback);
     m_brainCloudClientRef.SendRequest(sc);
 }

 /// <summary>
 /// Completely deletes the player record and all data fully owned
 /// by the player. After calling this method, the player will need
 /// to re-authenticate and create a new profile.
 /// This is mostly used for debugging/qa.
 /// </summary>
 /// <remarks>
 /// Service Name - PlayerState
 /// Service Operation - FullReset
 /// </remarks>
 /// <param name="in_success">
 /// The success callback.
 /// </param>
 /// <param name="in_failure">
 /// The failure callback.
 /// </param>
 /// <param name="in_cbObject">
 /// The user object sent to the callback.
 /// </param>
 /// <returns> The JSON returned in the callback is as follows:
 /// {
 ///   "status":200,
 ///   "data":null
 /// }
 /// </returns>
 public void DeletePlayer(
     SuccessCallback in_success = null,
     FailureCallback in_failure = null,
     object in_cbObject = null)
 {
     ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
     ServerCall sc = new ServerCall(ServiceName.PlayerState, ServiceOperation.FullReset, null, callback);
     m_brainCloudClientRef.SendRequest(sc);
 }

        /// <summary>
        /// Cancels a match
        /// </summary>
        /// <remarks>
        /// Service Name - OneWayMatch
        /// Service Operation - CancelMatch
        /// </remarks>
        /// <param name="in_playbackStreamId">
        /// The playback stream id returned in the start match
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns> The JSON returned in the callback is as follows:
        /// {
        ///   "status": 200,
        ///   "data": null
        /// }
        /// </returns>
        public void CancelMatch(
            string in_playbackStreamId,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data[OperationParam.OfflineMatchServicePlaybackStreamId.Value] = in_playbackStreamId;

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.OneWayMatch, ServiceOperation.CancelMatch, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        /// <summary>
        /// Decrements player rating
        /// </summary>
        /// <remarks>
        /// Service Name - MatchMaking
        /// Service Operation - DecrementPlayerRating
        /// </remarks>
        /// <param name="in_decrement">
        /// The decrement amount
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns> The JSON returned in the callback is as follows:
        /// {
        ///   "status": 200,
        ///   "data": null
        /// }
        /// </returns>
        public void DecrementPlayerRating(
            long in_decrement,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data[OperationParam.MatchMakingServicePlayerRating.Value] = in_decrement;

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.MatchMaking, ServiceOperation.DecrementPlayerRating, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        /// <summary>
        /// Gets the player's currency for the given currency type
        /// or all currency types if null passed in.
        /// </summary>
        /// <remarks>
        /// Service Name - Product
        /// Service Operation - GetPlayerVC
        /// </remarks>
        /// <param name="in_currencyType">
        /// The currency type to retrieve or null
        /// if all currency types are being requested.
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns> The JSON returned in the callback is as follows:
        /// {
        ///   "status":200,
        ///   "data": {
        ///     "updatedAt": 1395693676208,
        ///     "currencyMap": {
        ///       "gold": {
        ///         "purchased": 0,
        ///         "balance": 0,
        ///         "consumed": 0,
        ///         "awarded": 0
        ///       }
        ///     },
        ///     "playerId": "6ea79853-4025-4159-8014-60a6f17ac4e6",
        ///     "createdAt": 1395693676208
        ///   }
        /// }
        /// </returns>
        public void GetCurrency(
            string in_currencyType,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data[OperationParam.ProductServiceGetPlayerVCId.Value] = in_currencyType;

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.Product, ServiceOperation.GetPlayerVC, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        /// <summary>
        /// Starts a match
        /// </summary>
        /// <remarks>
        /// Service Name - OneWayMatch
        /// Service Operation - StartMatch
        /// </remarks>
        /// <param name="in_otherPlayerId"> The player to start a match with </param>
        /// <param name="in_rangeDelta"> The range delta used for the initial match search </param>
        /// <param name="in_success"> The success callback. </param>
        /// <param name="in_failure"> The failure callback. </param>
        /// <param name="in_cbObject"> The user object sent to the callback. </param>
        /// <returns> The JSON returned in the callback is as follows:
        /// {
        ///    "status": 200,
        ///    "data": {
        ///        "playbackStreamId": "d18719db-9d02-2341-b62f-8e2f013369be",
        ///        "initiatingPlayerId": "d175f6ac-9221-4adc-aea4-f25f2426ff62",
        ///        "targetPlayerId": "07a0d23e-996b-4488-90ae-cb438342423a54",
        ///        "status": "STARTED",
        ///        "summary": {},
        ///        "initialSharedData": {
        ///            "entities": [],
        ///            "statistics": {}
        ///        },
        ///        "events": [],
        ///        "createdAt": 1437419496282,
        ///        "updatedAt": 1437419496282
        ///    }
        /// }
        /// </returns>
        public void StartMatch(
            string in_otherPlayerId,
            long in_rangeDelta,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data[OperationParam.OfflineMatchServicePlayerId.Value] = in_otherPlayerId;
            data[OperationParam.OfflineMatchServiceRangeDelta.Value] = in_rangeDelta;

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.OneWayMatch, ServiceOperation.StartMatch, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        /// <summary>
        /// Retrieves profile information for the specified user.
        /// </summary>
        /// <remarks>
        /// Service Name - Friend
        /// Service Operation - GetFriendProfileInfo
        /// </remarks>
        /// <param name="in_friendId">
        /// Profile Id of friend who owns entity.
        /// </param>
        /// <param name="in_authenticationType">
        /// The authentication type used for this friend id e.g. Facebook
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns> The JSON returned in the callback
        /// {
        ///   "status":200,
        ///   "data": {
        ///     "playerId" : "17c7ee96-1b73-43d0-8817-cba1953bbf57",
        ///     "playerName" : "Donald Trump",
        ///     "email" : "[email protected]",
        ///     "playerSummaryData" : {},
        ///   }
        /// }
        /// </returns>
        public void GetFriendProfileInfo(
            string in_friendId,
            string in_authenticationType,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data[OperationParam.FriendServiceFriendId.Value] = in_friendId;
            data[OperationParam.FriendServiceAuthenticationType.Value] = in_authenticationType;

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.Friend, ServiceOperation.GetFriendProfileInfo, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        /// <summary>
        /// Returns a particular entity of a particular friend.
        /// </summary>
        /// <remarks>
        /// Service Name - Friend
        /// Service Operation - ReadFriendEntity
        /// </remarks>
        /// <param name="in_entityId">
        /// Id of entity to retrieve.
        /// </param>
        /// <param name="in_friendId">
        /// Profile Id of friend who owns entity.
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns> The JSON returned in the callback
        /// </returns>
        public void ReadFriendEntity(
            string in_entityId,
            string in_friendId,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data[OperationParam.FriendServiceEntityId.Value] = in_entityId;
            data[OperationParam.FriendServiceFriendId.Value] = in_friendId;

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.Friend, ServiceOperation.ReadFriendEntity, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        /// <summary>
        /// Delete an event out of the player's incoming mailbox.
        /// </summary>
        /// <remarks>
        /// Service Name - Event
        /// Service Operation - DeleteIncoming
        /// </remarks>
        /// <param name="in_fromPlayerId">
        /// The id of the player who sent the event
        /// </param>
        /// <param name="in_eventId">
        /// The event id
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns> The JSON returned in the callback is as follows:
        /// {
        ///   "status":200,
        ///   "data":null
        /// }
        /// </returns>
        public void DeleteIncomingEvent(
            string in_fromPlayerId,
            ulong in_eventId,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data[OperationParam.EventServiceDeleteIncomingFromId.Value] = in_fromPlayerId;
            data[OperationParam.EventServiceDeleteIncomingEventId.Value] = in_eventId;

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.Event, ServiceOperation.DeleteIncoming, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        /// <summary>
        /// Marks the given match as abandoned.
        /// </summary>
        /// <remarks>
        /// Service Name - AsyncMatch
        /// Service Operation - Abandon
        /// </remarks>
        /// <param name="ownerId">
        /// Match owner identifier
        /// </param>
        /// <param name="matchId">
        /// Match identifier
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns>
        /// {
        ///     "status": 200,
        ///     "data": {}
        /// }
        /// </returns>
        public void AbandonMatch(
            string in_ownerId,
            string in_matchId,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();

            data["ownerId"] = in_ownerId;
            data["matchId"] = in_matchId;

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.AsyncMatch, ServiceOperation.Abandon, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        /// <summary>
        /// Executes a script on the server.
        /// </summary>
        /// <remarks>
        /// Service Name - Script
        /// Service Operation - Run
        /// </remarks>
        /// <param name="in_scriptName">
        /// The name of the script to be run
        /// </param>
        /// <param name="in_jsonScriptData">
        /// Data to be sent to the script in json format
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns> The JSON returned in the callback is as follows:
        /// {
        ///   "status":200,
        ///   "data":null //// this value depends on what the script returns
        /// }
        /// @see The API documentation site for more details on cloud code
        /// </returns>
        public void RunScript(
            string in_scriptName,
            string in_jsonScriptData,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data[OperationParam.ScriptServiceRunScriptName.Value] = in_scriptName;

            if (Util.IsOptionalParameterValid(in_jsonScriptData))
            {
                Dictionary<string, object> scriptData = JsonReader.Deserialize<Dictionary<string, object>>(in_jsonScriptData);
                data[OperationParam.ScriptServiceRunScriptData.Value] = scriptData;
            }

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.Script, ServiceOperation.Run, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        /// <summary>
        /// Sends an array of file details and returns 
        /// the details of any of those files that have changed
        /// </summary>
        /// <remarks>
        /// Service Name - S3Handling
        /// Service Operation - GetUpdatedFiles
        /// </remarks>
        /// <param name="in_category">  
        /// Category of files on server to compare against
        /// </param>
        /// <param name="in_fileDetailsJson">  
        /// An array of file details
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns>  The JSON returned in the callback is as follows. 
        /// {
        ///     "status": 200,
        ///     "fileDetails": [
        ///         {
        ///             "gameId": "12311331",
        ///             "fileId": "3780516b-14f8-4055-8899-8eaab6ac7e82",
        ///             "shortName": "Test Doc",
        ///             "fileName": "testDoc.txt",
        ///             "type": "g",
        ///             "subType": "cust",
        ///             "category": null,
        ///             "fileSize": 4,
        ///             "dateUploaded": 1437154770000,
        ///             "relativeUrl": "/cust/testDoc.txt",
        ///             "absoluteUrl": "http://internal.braincloudservers.com/s3/portal/g/12311331/cust/testDoc.txt",
        ///             "md5Hash": "d41d8cd98f00b204e9800998ecf8427e"
        ///         }
        ///     ]
        /// }
        /// </returns>
        public void GetUpdatedFiles(
            string in_category,
            string in_fileDetailsJson,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();

            if (Util.IsOptionalParameterValid(in_category))
            {
                data[OperationParam.S3HandlingServiceFileCategory.Value] = in_category;
            }

            data[OperationParam.S3HandlingServiceFileDetails.Value] = JsonReader.Deserialize<object[]>(in_fileDetailsJson);

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.S3Handling, ServiceOperation.GetUpdatedFiles, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        public void Tweet(
            string in_token,
            string in_secret,
            string in_tweet,
            string in_picture,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data[OperationParam.TwitterServiceTweetToken.Value] = in_token;
            data[OperationParam.TwitterServiceTweetSecret.Value] = in_secret;
            data[OperationParam.TwitterServiceTweetTweet.Value] = in_tweet;

            if (Util.IsOptionalParameterValid(in_picture))
            {
                data[OperationParam.TwitterServiceTweetPic.Value] = in_picture;
            }

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.Event, ServiceOperation.Send, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        /// <summary>
        /// Verify ITunes Receipt. On success, the player will be awarded the 
        /// associated currencies.
        /// </summary>
        /// <remarks>
        /// Service Name - product
        /// Service Operation - OP_CASH_IN_RECEIPT
        /// </remarks>
        /// <param name="in_base64EncReceiptData">
        /// Base64 encoded receipt data
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns> The JSON returned in the callback is as follows:
        /// {
        ///   "status": 200,
        ///   "data":
        ///   {
        ///      "playerCurrency" : {
        ///         "playerId" : "sfhsjdfhfjhf",
        ///         "currencyMap" : {
        ///             "coin" : {
        ///                 "purchased" : NumberLong(0),
        ///                 "balance" : NumberLong(5000),
        ///                 "consumed" : NumberLong(0),
        ///                 "awarded" : NumberLong(5000)
        ///             },
        ///             "bar" : {
        ///                 "purchased" : NumberLong(0),
        ///                 "balance" : NumberLong(2),
        ///                 "consumed" : NumberLong(0),
        ///                 "awarded" : NumberLong(2)
        ///             }
        ///         },
        ///         "createdAt" : 763578645786,
        ///         "updatedAt" : 8692486255764,
        ///       },
        ///       "appleReceipt" : "gsgsfvgvg",
        ///       "status" : 0,
        ///       "server_time" : 987490827457
        ///   }
        /// }
        /// </returns>
        public void VerifyItunesReceipt(String in_base64EncReceiptData, SuccessCallback in_callback = null, FailureCallback in_failure = null, object in_cbObject = null)
        {
            Dictionary<string, object> message = new Dictionary<string, object>();
            message[OperationParam.ProductServiceOpCashInReceiptReceipt.Value] = in_base64EncReceiptData;

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_callback, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.Product, ServiceOperation.CashInReceipt, message, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

        /// <summary>
        /// Initialize Steam Transaction
        /// </summary>
        /// <remarks>
        /// Service Name - product
        /// Service Operation - INITIALIZE_STEAM_TRANSACTION
        /// </remarks>
        /// <param name="in_language">
        /// ISO 639-1 language code
        /// </param>
        /// <param name="in_items">
        /// Items to purchase
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns> The JSON returned in the callback is as follows:
        /// {
        ///   "status": 200,
        ///   "data":
        ///   {
        ///      "steamStatus" : 200,
        ///      "steamData" :
        ///      {
        ///      }
        ///   }
        /// }
        /// </returns>
        public void StartSteamTransaction(
            String in_language,
            String in_itemId,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data[OperationParam.ProductServiceLanguage.Value] = in_language;
            data[OperationParam.ProductServiceItemId.Value] = in_itemId;

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.Product, ServiceOperation.StartSteamTransaction, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

 /// <summary>
 /// Resets the player's currency back to zero.
 /// </summary>
 /// <remarks>
 /// Service Name - Product
 /// Service Operation - ResetPlayerVC
 /// </remarks>
 /// <param name="in_success">
 /// The success callback.
 /// </param>
 /// <param name="in_failure">
 /// The failure callback.
 /// </param>
 /// <param name="in_cbObject">
 /// The user object sent to the callback.
 /// </param>
 /// <returns> The JSON returned in the callback is as follows:
 /// {
 ///   "status":200,
 ///   "data":null
 /// }
 /// </returns>
 public void ResetCurrency(
     SuccessCallback in_success = null,
     FailureCallback in_failure = null,
     object in_cbObject = null)
 {
     ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
     ServerCall sc = new ServerCall(ServiceName.Product, ServiceOperation.ResetPlayerVC, null, callback);
     m_brainCloudClientRef.SendRequest(sc);
 }

        /// <summary>
        /// Method gets the active sales inventory for the passed-in
        /// currency type and category.
        /// </summary>
        /// <remarks>
        /// Service Name - Product
        /// Service Operation - GetInventory
        /// </remarks>
        /// <param name="in_platform">
        /// The store platform. Valid stores are:
        /// - iTunes
        /// - Facebook
        /// - AppWorld
        /// - Steam
        /// - Windows
        /// - WindowsPhone
        /// - GooglePlay
        /// </param>
        /// <param name="in_userCurrency">
        /// The currency to retrieve the sales
        /// inventory for. This is only used for Steam and Facebook stores.
        /// </param>
        /// <param name="in_category">
        /// The product category
        /// </param>
        /// <param name="in_success">
        /// The success callback.
        /// </param>
        /// <param name="in_failure">
        /// The failure callback.
        /// </param>
        /// <param name="in_cbObject">
        /// The user object sent to the callback.
        /// </param>
        /// <returns> The JSON returned in the callback is as follows:
        /// {
        ///   "status":200,
        ///   "data":{
        ///      "product_inventory":[
        ///          {
        ///              "gameId":"com.roger.football",
        ///              "itemId":"0000001",
        ///              "title":"Item 0000001",
        ///              "description":"Buy 5 footballs",
        ///              "imageUrl":"http:",
        ///              "fbUrl":"http:",
        ///              "currency":{"footballs":5},
        ///              "priceData":{"currency":"USD","price":1000}
        ///           }
        ///       ],
        ///       "server_time":1398960658981
        ///    }
        /// }
        /// </returns>
        public void GetSalesInventoryByCategory(
            string in_platform,
            string in_userCurrency,
            string in_category,
            SuccessCallback in_success = null,
            FailureCallback in_failure = null,
            object in_cbObject = null)
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data[OperationParam.ProductServiceGetInventoryPlatform.Value] = in_platform;
            if (Util.IsOptionalParameterValid(in_userCurrency))
            {
                data[OperationParam.ProductServiceGetInventoryUserCurrency.Value] = in_userCurrency;
            }
            if (Util.IsOptionalParameterValid(in_category))
            {
                data[OperationParam.ProductServiceGetInventoryCategory.Value] = in_category;
            }

            ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
            ServerCall sc = new ServerCall(ServiceName.Product, ServiceOperation.GetInventory, data, callback);
            m_brainCloudClientRef.SendRequest(sc);
        }

 /// <summary>
 /// Returns the eligible promotions for the player.
 /// </summary>
 /// <remarks>
 /// Service Name - Product
 /// Service Operation - EligiblePromotions
 /// </remarks>
 /// <param name="in_success">
 /// The success callback.
 /// </param>
 /// <param name="in_failure">
 /// The failure callback.
 /// </param>
 /// <param name="in_cbObject">
 /// The user object sent to the callback.
 /// </param>
 /// <returns> The JSON returned in the callback is as follows:
 /// {
 ///   "status":200,
 ///   "data":{
 /// "promotions": [
 ///  {
 ///   "gameId": "10019",
 ///   "promotionId": 9,
 ///   "type": "SCHEDULED",
 ///   "name": "session >= 2",
 ///   "message": "test1",
 ///   "enabled": true,
 ///   "targetAllUsers": false,
 ///   &