#if !DISABLE_PLAYFABCLIENT_API
using System;
using System.Collections.Generic;
using PlayFab.SharedModels;
namespace PlayFab.ClientModels
{
[Serializable]
public class AcceptTradeRequest : PlayFabRequestCommon
{
///
/// Items from the accepting player's inventory in exchange for the offered items in the trade. In the case of a gift, this
/// will be null.
///
public List AcceptedInventoryInstanceIds;
///
/// Player who opened the trade.
///
public string OfferingPlayerId;
///
/// Trade identifier.
///
public string TradeId;
}
[Serializable]
public class AcceptTradeResponse : PlayFabResultCommon
{
///
/// Details about trade which was just accepted.
///
public TradeInfo Trade;
}
public enum AdActivity
{
Opened,
Closed,
Start,
End
}
[Serializable]
public class AdCampaignAttributionModel : PlayFabBaseModel
{
///
/// UTC time stamp of attribution
///
public DateTime AttributedAt;
///
/// Attribution campaign identifier
///
public string CampaignId;
///
/// Attribution network name
///
public string Platform;
}
[Serializable]
public class AddFriendRequest : PlayFabRequestCommon
{
///
/// Email address of the user to attempt to add to the local user's friend list.
///
public string FriendEmail;
///
/// PlayFab identifier of the user to attempt to add to the local user's friend list.
///
public string FriendPlayFabId;
///
/// Title-specific display name of the user to attempt to add to the local user's friend list.
///
public string FriendTitleDisplayName;
///
/// PlayFab username of the user to attempt to add to the local user's friend list.
///
public string FriendUsername;
}
[Serializable]
public class AddFriendResult : PlayFabResultCommon
{
///
/// True if the friend request was processed successfully.
///
public bool Created;
}
[Serializable]
public class AddGenericIDRequest : PlayFabRequestCommon
{
///
/// Generic service identifier to add to the player account.
///
public GenericServiceId GenericId;
}
[Serializable]
public class AddGenericIDResult : PlayFabResultCommon
{
}
///
/// This API adds a contact email to the player's profile. If the player's profile already contains a contact email, it will
/// update the contact email to the email address specified.
///
[Serializable]
public class AddOrUpdateContactEmailRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// The new contact email to associate with the player.
///
public string EmailAddress;
}
[Serializable]
public class AddOrUpdateContactEmailResult : PlayFabResultCommon
{
}
[Serializable]
public class AddSharedGroupMembersRequest : PlayFabRequestCommon
{
///
/// An array of unique PlayFab assigned ID of the user on whom the operation will be performed.
///
public List PlayFabIds;
///
/// Unique identifier for the shared group.
///
public string SharedGroupId;
}
[Serializable]
public class AddSharedGroupMembersResult : PlayFabResultCommon
{
}
[Serializable]
public class AddUsernamePasswordRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// User email address attached to their account
///
public string Email;
///
/// Password for the PlayFab account (6-100 characters)
///
public string Password;
///
/// PlayFab username for the account (3-20 characters)
///
public string Username;
}
///
/// Each account must have a unique username and email address in the PlayFab service. Once created, the account may be
/// associated with additional accounts (Steam, Facebook, Game Center, etc.), allowing for added social network lists and
/// achievements systems. This can also be used to provide a recovery method if the user loses their original means of
/// access.
///
[Serializable]
public class AddUsernamePasswordResult : PlayFabResultCommon
{
///
/// PlayFab unique user name.
///
public string Username;
}
///
/// This API must be enabled for use as an option in the game manager website. It is disabled by default.
///
[Serializable]
public class AddUserVirtualCurrencyRequest : PlayFabRequestCommon
{
///
/// Amount to be added to the user balance of the specified virtual currency.
///
public int Amount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Name of the virtual currency which is to be incremented.
///
public string VirtualCurrency;
}
///
/// A single ad placement details including placement and reward information
///
[Serializable]
public class AdPlacementDetails : PlayFabBaseModel
{
///
/// Placement unique ID
///
public string PlacementId;
///
/// Placement name
///
public string PlacementName;
///
/// If placement has viewing limits indicates how many views are left
///
public int? PlacementViewsRemaining;
///
/// If placement has viewing limits indicates when they will next reset
///
public double? PlacementViewsResetMinutes;
///
/// Optional URL to a reward asset
///
public string RewardAssetUrl;
///
/// Reward description
///
public string RewardDescription;
///
/// Reward unique ID
///
public string RewardId;
///
/// Reward name
///
public string RewardName;
}
///
/// Details for each item granted
///
[Serializable]
public class AdRewardItemGranted : PlayFabBaseModel
{
///
/// Catalog ID
///
public string CatalogId;
///
/// Catalog item display name
///
public string DisplayName;
///
/// Inventory instance ID
///
public string InstanceId;
///
/// Item ID
///
public string ItemId;
}
///
/// Details on what was granted to the player
///
[Serializable]
public class AdRewardResults : PlayFabBaseModel
{
///
/// Array of the items granted to the player
///
public List GrantedItems;
///
/// Dictionary of virtual currencies that were granted to the player
///
public Dictionary GrantedVirtualCurrencies;
///
/// Dictionary of statistics that were modified for the player
///
public Dictionary IncrementedStatistics;
}
///
/// More information can be found on configuring your game for the Google Cloud Messaging service in the Google developer
/// documentation, here: http://developer.android.com/google/gcm/client.html. The steps to configure and send Push
/// Notifications is described in the PlayFab tutorials, here:
/// https://docs.microsoft.com/gaming/playfab/features/engagement/push-notifications/quickstart.
///
[Serializable]
public class AndroidDevicePushNotificationRegistrationRequest : PlayFabRequestCommon
{
///
/// Message to display when confirming push notification.
///
public string ConfirmationMessage;
///
/// Registration ID provided by the Google Cloud Messaging service when the title registered to receive push notifications
/// (see the GCM documentation, here: http://developer.android.com/google/gcm/client.html).
///
public string DeviceToken;
///
/// If true, send a test push message immediately after sucessful registration. Defaults to false.
///
public bool? SendPushNotificationConfirmation;
}
[Serializable]
public class AndroidDevicePushNotificationRegistrationResult : PlayFabResultCommon
{
}
///
/// If you have an ad attribution partner enabled, this will post an install to their service to track the device. It uses
/// the given device id to match based on clicks on ads.
///
[Serializable]
public class AttributeInstallRequest : PlayFabRequestCommon
{
///
/// The adid for this device.
///
public string Adid;
///
/// The IdentifierForAdvertisers for iOS Devices.
///
public string Idfa;
}
[Serializable]
public class AttributeInstallResult : PlayFabResultCommon
{
}
[Serializable]
public class CancelTradeRequest : PlayFabRequestCommon
{
///
/// Trade identifier.
///
public string TradeId;
}
[Serializable]
public class CancelTradeResponse : PlayFabResultCommon
{
///
/// Details about trade which was just canceled.
///
public TradeInfo Trade;
}
[Serializable]
public class CartItem : PlayFabBaseModel
{
///
/// Description of the catalog item.
///
public string Description;
///
/// Display name for the catalog item.
///
public string DisplayName;
///
/// Class name to which catalog item belongs.
///
public string ItemClass;
///
/// Unique identifier for the catalog item.
///
public string ItemId;
///
/// Unique instance identifier for this catalog item.
///
public string ItemInstanceId;
///
/// Cost of the catalog item for each applicable real world currency.
///
public Dictionary RealCurrencyPrices;
///
/// Amount of each applicable virtual currency which will be received as a result of purchasing this catalog item.
///
public Dictionary VCAmount;
///
/// Cost of the catalog item for each applicable virtual currency.
///
public Dictionary VirtualCurrencyPrices;
}
///
/// A purchasable item from the item catalog
///
[Serializable]
public class CatalogItem : PlayFabBaseModel
{
///
/// defines the bundle properties for the item - bundles are items which contain other items, including random drop tables
/// and virtual currencies
///
public CatalogItemBundleInfo Bundle;
///
/// if true, then an item instance of this type can be used to grant a character to a user.
///
public bool CanBecomeCharacter;
///
/// catalog version for this item
///
public string CatalogVersion;
///
/// defines the consumable properties (number of uses, timeout) for the item
///
public CatalogItemConsumableInfo Consumable;
///
/// defines the container properties for the item - what items it contains, including random drop tables and virtual
/// currencies, and what item (if any) is required to open it via the UnlockContainerItem API
///
public CatalogItemContainerInfo Container;
///
/// game specific custom data
///
public string CustomData;
///
/// text description of item, to show in-game
///
public string Description;
///
/// text name for the item, to show in-game
///
public string DisplayName;
///
/// If the item has IsLImitedEdition set to true, and this is the first time this ItemId has been defined as a limited
/// edition item, this value determines the total number of instances to allocate for the title. Once this limit has been
/// reached, no more instances of this ItemId can be created, and attempts to purchase or grant it will return a Result of
/// false for that ItemId. If the item has already been defined to have a limited edition count, or if this value is less
/// than zero, it will be ignored.
///
public int InitialLimitedEditionCount;
///
/// BETA: If true, then only a fixed number can ever be granted.
///
public bool IsLimitedEdition;
///
/// if true, then only one item instance of this type will exist and its remaininguses will be incremented instead.
/// RemainingUses will cap out at Int32.Max (2,147,483,647). All subsequent increases will be discarded
///
public bool IsStackable;
///
/// if true, then an item instance of this type can be traded between players using the trading APIs
///
public bool IsTradable;
///
/// class to which the item belongs
///
public string ItemClass;
///
/// unique identifier for this item
///
public string ItemId;
///
/// URL to the item image. For Facebook purchase to display the image on the item purchase page, this must be set to an HTTP
/// URL.
///
public string ItemImageUrl;
///
/// override prices for this item for specific currencies
///
public Dictionary RealCurrencyPrices;
///
/// list of item tags
///
public List Tags;
///
/// price of this item in virtual currencies and "RM" (the base Real Money purchase price, in USD pennies)
///
public Dictionary VirtualCurrencyPrices;
}
[Serializable]
public class CatalogItemBundleInfo : PlayFabBaseModel
{
///
/// unique ItemId values for all items which will be added to the player inventory when the bundle is added
///
public List BundledItems;
///
/// unique TableId values for all RandomResultTable objects which are part of the bundle (random tables will be resolved and
/// add the relevant items to the player inventory when the bundle is added)
///
public List BundledResultTables;
///
/// virtual currency types and balances which will be added to the player inventory when the bundle is added
///
public Dictionary BundledVirtualCurrencies;
}
[Serializable]
public class CatalogItemConsumableInfo : PlayFabBaseModel
{
///
/// number of times this object can be used, after which it will be removed from the player inventory
///
public uint? UsageCount;
///
/// duration in seconds for how long the item will remain in the player inventory - once elapsed, the item will be removed
/// (recommended minimum value is 5 seconds, as lower values can cause the item to expire before operations depending on
/// this item's details have completed)
///
public uint? UsagePeriod;
///
/// all inventory item instances in the player inventory sharing a non-null UsagePeriodGroup have their UsagePeriod values
/// added together, and share the result - when that period has elapsed, all the items in the group will be removed
///
public string UsagePeriodGroup;
}
///
/// Containers are inventory items that can hold other items defined in the catalog, as well as virtual currency, which is
/// added to the player inventory when the container is unlocked, using the UnlockContainerItem API. The items can be
/// anything defined in the catalog, as well as RandomResultTable objects which will be resolved when the container is
/// unlocked. Containers and their keys should be defined as Consumable (having a limited number of uses) in their catalog
/// defintiions, unless the intent is for the player to be able to re-use them infinitely.
///
[Serializable]
public class CatalogItemContainerInfo : PlayFabBaseModel
{
///
/// unique ItemId values for all items which will be added to the player inventory, once the container has been unlocked
///
public List ItemContents;
///
/// ItemId for the catalog item used to unlock the container, if any (if not specified, a call to UnlockContainerItem will
/// open the container, adding the contents to the player inventory and currency balances)
///
public string KeyItemId;
///
/// unique TableId values for all RandomResultTable objects which are part of the container (once unlocked, random tables
/// will be resolved and add the relevant items to the player inventory)
///
public List ResultTableContents;
///
/// virtual currency types and balances which will be added to the player inventory when the container is unlocked
///
public Dictionary VirtualCurrencyContents;
}
[Serializable]
public class CharacterInventory : PlayFabBaseModel
{
///
/// The id of this character.
///
public string CharacterId;
///
/// The inventory of this character.
///
public List Inventory;
}
[Serializable]
public class CharacterLeaderboardEntry : PlayFabBaseModel
{
///
/// PlayFab unique identifier of the character that belongs to the user for this leaderboard entry.
///
public string CharacterId;
///
/// Title-specific display name of the character for this leaderboard entry.
///
public string CharacterName;
///
/// Name of the character class for this entry.
///
public string CharacterType;
///
/// Title-specific display name of the user for this leaderboard entry.
///
public string DisplayName;
///
/// PlayFab unique identifier of the user for this leaderboard entry.
///
public string PlayFabId;
///
/// User's overall position in the leaderboard.
///
public int Position;
///
/// Specific value of the user's statistic.
///
public int StatValue;
}
[Serializable]
public class CharacterResult : PlayFabBaseModel
{
///
/// The id for this character on this player.
///
public string CharacterId;
///
/// The name of this character.
///
public string CharacterName;
///
/// The type-string that was given to this character on creation.
///
public string CharacterType;
}
public enum CloudScriptRevisionOption
{
Live,
Latest,
Specific
}
///
/// The final step in the purchasing process, this API finalizes the purchase with the payment provider, where applicable,
/// adding virtual goods to the player inventory (including random drop table resolution and recursive addition of bundled
/// items) and adjusting virtual currency balances for funds used or added. Note that this is a pull operation, and should
/// be polled regularly when a purchase is in progress. Please note that the processing time for inventory grants and
/// purchases increases fractionally the more items are in the inventory, and the more items are in the grant/purchase
/// operation.
///
[Serializable]
public class ConfirmPurchaseRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Purchase order identifier returned from StartPurchase.
///
public string OrderId;
}
///
/// When the FailedByPaymentProvider error is returned, it's important to check the ProviderErrorCode, ProviderErrorMessage,
/// and ProviderErrorDetails to understand the specific reason the payment was rejected, as in some rare cases, this may
/// mean that the provider hasn't completed some operation required to finalize the purchase.
///
[Serializable]
public class ConfirmPurchaseResult : PlayFabResultCommon
{
///
/// Array of items purchased.
///
public List Items;
///
/// Purchase order identifier.
///
public string OrderId;
///
/// Date and time of the purchase.
///
public DateTime PurchaseDate;
}
[Serializable]
public class ConsumeItemRequest : PlayFabRequestCommon
{
///
/// Unique PlayFab assigned ID for a specific character owned by a user
///
public string CharacterId;
///
/// Number of uses to consume from the item.
///
public int ConsumeCount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Unique instance identifier of the item to be consumed.
///
public string ItemInstanceId;
}
[Serializable]
public class ConsumeItemResult : PlayFabResultCommon
{
///
/// Unique instance identifier of the item with uses consumed.
///
public string ItemInstanceId;
///
/// Number of uses remaining on the item.
///
public int RemainingUses;
}
[Serializable]
public class ConsumeMicrosoftStoreEntitlementsRequest : PlayFabRequestCommon
{
///
/// Catalog version to use
///
public string CatalogVersion;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Marketplace specific payload containing details to fetch in app purchase transactions
///
public MicrosoftStorePayload MarketplaceSpecificData;
}
[Serializable]
public class ConsumeMicrosoftStoreEntitlementsResponse : PlayFabResultCommon
{
///
/// Details for the items purchased.
///
public List Items;
}
[Serializable]
public class ConsumePS5EntitlementsRequest : PlayFabRequestCommon
{
///
/// Catalog version to use
///
public string CatalogVersion;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Marketplace specific payload containing details to fetch in app purchase transactions
///
public PlayStation5Payload MarketplaceSpecificData;
}
[Serializable]
public class ConsumePS5EntitlementsResult : PlayFabResultCommon
{
///
/// Details for the items purchased.
///
public List Items;
}
[Serializable]
public class ConsumePSNEntitlementsRequest : PlayFabRequestCommon
{
///
/// Which catalog to match granted entitlements against. If null, defaults to title default catalog
///
public string CatalogVersion;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Id of the PlayStation :tm: Network service label to consume entitlements from
///
public int ServiceLabel;
}
[Serializable]
public class ConsumePSNEntitlementsResult : PlayFabResultCommon
{
///
/// Array of items granted to the player as a result of consuming entitlements.
///
public List ItemsGranted;
}
[Serializable]
public class ConsumeXboxEntitlementsRequest : PlayFabRequestCommon
{
///
/// Catalog version to use
///
public string CatalogVersion;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Token provided by the Xbox Live SDK/XDK method GetTokenAndSignatureAsync("POST", "https://playfabapi.com/", "").
///
public string XboxToken;
}
[Serializable]
public class ConsumeXboxEntitlementsResult : PlayFabResultCommon
{
///
/// Details for the items purchased.
///
public List Items;
}
[Serializable]
public class ContactEmailInfoModel : PlayFabBaseModel
{
///
/// The email address
///
public string EmailAddress;
///
/// The name of the email info data
///
public string Name;
///
/// The verification status of the email
///
public EmailVerificationStatus? VerificationStatus;
}
public enum ContinentCode
{
AF,
AN,
AS,
EU,
NA,
OC,
SA,
Unknown
}
public enum CountryCode
{
AF,
AX,
AL,
DZ,
AS,
AD,
AO,
AI,
AQ,
AG,
AR,
AM,
AW,
AU,
AT,
AZ,
BS,
BH,
BD,
BB,
BY,
BE,
BZ,
BJ,
BM,
BT,
BO,
BQ,
BA,
BW,
BV,
BR,
IO,
BN,
BG,
BF,
BI,
KH,
CM,
CA,
CV,
KY,
CF,
TD,
CL,
CN,
CX,
CC,
CO,
KM,
CG,
CD,
CK,
CR,
CI,
HR,
CU,
CW,
CY,
CZ,
DK,
DJ,
DM,
DO,
EC,
EG,
SV,
GQ,
ER,
EE,
ET,
FK,
FO,
FJ,
FI,
FR,
GF,
PF,
TF,
GA,
GM,
GE,
DE,
GH,
GI,
GR,
GL,
GD,
GP,
GU,
GT,
GG,
GN,
GW,
GY,
HT,
HM,
VA,
HN,
HK,
HU,
IS,
IN,
ID,
IR,
IQ,
IE,
IM,
IL,
IT,
JM,
JP,
JE,
JO,
KZ,
KE,
KI,
KP,
KR,
KW,
KG,
LA,
LV,
LB,
LS,
LR,
LY,
LI,
LT,
LU,
MO,
MK,
MG,
MW,
MY,
MV,
ML,
MT,
MH,
MQ,
MR,
MU,
YT,
MX,
FM,
MD,
MC,
MN,
ME,
MS,
MA,
MZ,
MM,
NA,
NR,
NP,
NL,
NC,
NZ,
NI,
NE,
NG,
NU,
NF,
MP,
NO,
OM,
PK,
PW,
PS,
PA,
PG,
PY,
PE,
PH,
PN,
PL,
PT,
PR,
QA,
RE,
RO,
RU,
RW,
BL,
SH,
KN,
LC,
MF,
PM,
VC,
WS,
SM,
ST,
SA,
SN,
RS,
SC,
SL,
SG,
SX,
SK,
SI,
SB,
SO,
ZA,
GS,
SS,
ES,
LK,
SD,
SR,
SJ,
SZ,
SE,
CH,
SY,
TW,
TJ,
TZ,
TH,
TL,
TG,
TK,
TO,
TT,
TN,
TR,
TM,
TC,
TV,
UG,
UA,
AE,
GB,
US,
UM,
UY,
UZ,
VU,
VE,
VN,
VG,
VI,
WF,
EH,
YE,
ZM,
ZW,
Unknown
}
///
/// If SharedGroupId is specified, the service will attempt to create a group with that identifier, and will return an error
/// if it is already in use. If no SharedGroupId is specified, a random identifier will be assigned.
///
[Serializable]
public class CreateSharedGroupRequest : PlayFabRequestCommon
{
///
/// Unique identifier for the shared group (a random identifier will be assigned, if one is not specified).
///
public string SharedGroupId;
}
[Serializable]
public class CreateSharedGroupResult : PlayFabResultCommon
{
///
/// Unique identifier for the shared group.
///
public string SharedGroupId;
}
public enum Currency
{
AED,
AFN,
ALL,
AMD,
ANG,
AOA,
ARS,
AUD,
AWG,
AZN,
BAM,
BBD,
BDT,
BGN,
BHD,
BIF,
BMD,
BND,
BOB,
BRL,
BSD,
BTN,
BWP,
BYR,
BZD,
CAD,
CDF,
CHF,
CLP,
CNY,
COP,
CRC,
CUC,
CUP,
CVE,
CZK,
DJF,
DKK,
DOP,
DZD,
EGP,
ERN,
ETB,
EUR,
FJD,
FKP,
GBP,
GEL,
GGP,
GHS,
GIP,
GMD,
GNF,
GTQ,
GYD,
HKD,
HNL,
HRK,
HTG,
HUF,
IDR,
ILS,
IMP,
INR,
IQD,
IRR,
ISK,
JEP,
JMD,
JOD,
JPY,
KES,
KGS,
KHR,
KMF,
KPW,
KRW,
KWD,
KYD,
KZT,
LAK,
LBP,
LKR,
LRD,
LSL,
LYD,
MAD,
MDL,
MGA,
MKD,
MMK,
MNT,
MOP,
MRO,
MUR,
MVR,
MWK,
MXN,
MYR,
MZN,
NAD,
NGN,
NIO,
NOK,
NPR,
NZD,
OMR,
PAB,
PEN,
PGK,
PHP,
PKR,
PLN,
PYG,
QAR,
RON,
RSD,
RUB,
RWF,
SAR,
SBD,
SCR,
SDG,
SEK,
SGD,
SHP,
SLL,
SOS,
SPL,
SRD,
STD,
SVC,
SYP,
SZL,
THB,
TJS,
TMT,
TND,
TOP,
TRY,
TTD,
TVD,
TWD,
TZS,
UAH,
UGX,
USD,
UYU,
UZS,
VEF,
VND,
VUV,
WST,
XAF,
XCD,
XDR,
XOF,
XPF,
YER,
ZAR,
ZMW,
ZWD
}
///
/// Any arbitrary information collected by the device
///
[Serializable]
public class DeviceInfoRequest : PlayFabRequestCommon
{
///
/// Information posted to the PlayStream Event. Currently arbitrary, and specific to the environment sending it.
///
public Dictionary Info;
}
public enum EmailVerificationStatus
{
Unverified,
Pending,
Confirmed
}
[Serializable]
public class EmptyResponse : PlayFabResultCommon
{
}
[Serializable]
public class EmptyResult : PlayFabResultCommon
{
}
///
/// Combined entity type and ID structure which uniquely identifies a single entity.
///
[Serializable]
public class EntityKey : PlayFabBaseModel
{
///
/// Unique ID of the entity.
///
public string Id;
///
/// Entity type. See https://docs.microsoft.com/gaming/playfab/features/data/entities/available-built-in-entity-types
///
public string Type;
}
[Serializable]
public class EntityTokenResponse : PlayFabBaseModel
{
///
/// The entity id and type.
///
public EntityKey Entity;
///
/// The token used to set X-EntityToken for all entity based API calls.
///
public string EntityToken;
///
/// The time the token will expire, if it is an expiring token, in UTC.
///
public DateTime? TokenExpiration;
}
[Serializable]
public class ExecuteCloudScriptRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// The name of the CloudScript function to execute
///
public string FunctionName;
///
/// Object that is passed in to the function as the first argument
///
public object FunctionParameter;
///
/// Generate a 'player_executed_cloudscript' PlayStream event containing the results of the function execution and other
/// contextual information. This event will show up in the PlayStream debugger console for the player in Game Manager.
///
public bool? GeneratePlayStreamEvent;
///
/// Option for which revision of the CloudScript to execute. 'Latest' executes the most recently created revision, 'Live'
/// executes the current live, published revision, and 'Specific' executes the specified revision. The default value is
/// 'Specific', if the SpeificRevision parameter is specified, otherwise it is 'Live'.
///
public CloudScriptRevisionOption? RevisionSelection;
///
/// The specivic revision to execute, when RevisionSelection is set to 'Specific'
///
public int? SpecificRevision;
}
[Serializable]
public class ExecuteCloudScriptResult : PlayFabResultCommon
{
///
/// Number of PlayFab API requests issued by the CloudScript function
///
public int APIRequestsIssued;
///
/// Information about the error, if any, that occurred during execution
///
public ScriptExecutionError Error;
public double ExecutionTimeSeconds;
///
/// The name of the function that executed
///
public string FunctionName;
///
/// The object returned from the CloudScript function, if any
///
public object FunctionResult;
///
/// Flag indicating if the FunctionResult was too large and was subsequently dropped from this event. This only occurs if
/// the total event size is larger than 350KB.
///
public bool? FunctionResultTooLarge;
///
/// Number of external HTTP requests issued by the CloudScript function
///
public int HttpRequestsIssued;
///
/// Entries logged during the function execution. These include both entries logged in the function code using log.info()
/// and log.error() and error entries for API and HTTP request failures.
///
public List Logs;
///
/// Flag indicating if the logs were too large and were subsequently dropped from this event. This only occurs if the total
/// event size is larger than 350KB after the FunctionResult was removed.
///
public bool? LogsTooLarge;
public uint MemoryConsumedBytes;
///
/// Processor time consumed while executing the function. This does not include time spent waiting on API calls or HTTP
/// requests.
///
public double ProcessorTimeSeconds;
///
/// The revision of the CloudScript that executed
///
public int Revision;
}
public enum ExternalFriendSources
{
None,
Steam,
Facebook,
Xbox,
Psn,
All
}
[Serializable]
public class FacebookInstantGamesPlayFabIdPair : PlayFabBaseModel
{
///
/// Unique Facebook Instant Games identifier for a user.
///
public string FacebookInstantGamesId;
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the Facebook Instant Games identifier.
///
public string PlayFabId;
}
[Serializable]
public class FacebookPlayFabIdPair : PlayFabBaseModel
{
///
/// Unique Facebook identifier for a user.
///
public string FacebookId;
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the Facebook identifier.
///
public string PlayFabId;
}
[Serializable]
public class FriendInfo : PlayFabBaseModel
{
///
/// Available Facebook information (if the user and connected Facebook friend both have PlayFab Accounts in the same title).
///
public UserFacebookInfo FacebookInfo;
///
/// PlayFab unique identifier for this friend.
///
public string FriendPlayFabId;
///
/// Available Game Center information (if the user and connected Game Center friend both have PlayFab Accounts in the same
/// title).
///
public UserGameCenterInfo GameCenterInfo;
///
/// The profile of the user, if requested.
///
public PlayerProfileModel Profile;
///
/// Available PlayStation :tm: Network information, if the user connected PlayStation :tm Network friend both have PlayFab
/// Accounts in the same title.
///
public UserPsnInfo PSNInfo;
///
/// Available Steam information (if the user and connected Steam friend both have PlayFab Accounts in the same title).
///
public UserSteamInfo SteamInfo;
///
/// Tags which have been associated with this friend.
///
public List Tags;
///
/// Title-specific display name for this friend.
///
public string TitleDisplayName;
///
/// PlayFab unique username for this friend.
///
public string Username;
///
/// Available Xbox information, (if the user and connected Xbox Live friend both have PlayFab Accounts in the same title).
///
public UserXboxInfo XboxInfo;
}
[Serializable]
public class GameCenterPlayFabIdPair : PlayFabBaseModel
{
///
/// Unique Game Center identifier for a user.
///
public string GameCenterId;
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the Game Center identifier.
///
public string PlayFabId;
}
[Serializable]
public class GenericPlayFabIdPair : PlayFabBaseModel
{
///
/// Unique generic service identifier for a user.
///
public GenericServiceId GenericId;
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the given generic identifier.
///
public string PlayFabId;
}
[Serializable]
public class GenericServiceId : PlayFabBaseModel
{
///
/// Name of the service for which the player has a unique identifier.
///
public string ServiceName;
///
/// Unique identifier of the player in that service.
///
public string UserId;
}
[Serializable]
public class GetAccountInfoRequest : PlayFabRequestCommon
{
///
/// User email address for the account to find (if no Username is specified).
///
public string Email;
///
/// Unique PlayFab identifier of the user whose info is being requested. Optional, defaults to the authenticated user if no
/// other lookup identifier set.
///
public string PlayFabId;
///
/// Title-specific username for the account to find (if no Email is set). Note that if the non-unique Title Display Names
/// option is enabled for the title, attempts to look up users by Title Display Name will always return AccountNotFound.
///
public string TitleDisplayName;
///
/// PlayFab Username for the account to find (if no PlayFabId is specified).
///
public string Username;
}
///
/// This API retrieves details regarding the player in the PlayFab service. Note that when this call is used to retrieve
/// data about another player (not the one signed into the local client), some data, such as Personally Identifying
/// Information (PII), will be omitted for privacy reasons or to comply with the requirements of the platform belongs to.
/// The user account returned will be based on the identifier provided in priority order: PlayFabId, Username, Email, then
/// TitleDisplayName. If no identifier is specified, the currently signed in user's information will be returned.
///
[Serializable]
public class GetAccountInfoResult : PlayFabResultCommon
{
///
/// Account information for the local user.
///
public UserAccountInfo AccountInfo;
}
///
/// Using an AppId to return a list of valid ad placements for a player.
///
[Serializable]
public class GetAdPlacementsRequest : PlayFabRequestCommon
{
///
/// The current AppId to use
///
public string AppId;
///
/// Using the name or unique identifier, filter the result for get a specific placement.
///
public NameIdentifier Identifier;
}
///
/// Array of AdPlacementDetails
///
[Serializable]
public class GetAdPlacementsResult : PlayFabResultCommon
{
///
/// Array of results
///
public List AdPlacements;
}
[Serializable]
public class GetCatalogItemsRequest : PlayFabRequestCommon
{
///
/// Which catalog is being requested. If null, uses the default catalog.
///
public string CatalogVersion;
}
///
/// If CatalogVersion is not specified, only inventory items associated with the most recent version of the catalog will be
/// returned.
///
[Serializable]
public class GetCatalogItemsResult : PlayFabResultCommon
{
///
/// Array of items which can be purchased.
///
public List Catalog;
}
///
/// Data is stored as JSON key-value pairs. If the Keys parameter is provided, the data object returned will only contain
/// the data specific to the indicated Keys. Otherwise, the full set of custom character data will be returned.
///
[Serializable]
public class GetCharacterDataRequest : PlayFabRequestCommon
{
///
/// Unique PlayFab assigned ID for a specific character owned by a user
///
public string CharacterId;
///
/// The version that currently exists according to the caller. The call will return the data for all of the keys if the
/// version in the system is greater than this.
///
public uint? IfChangedFromDataVersion;
///
/// Specific keys to search for in the custom user data.
///
public List Keys;
///
/// Unique PlayFab identifier of the user to load data for. Optional, defaults to yourself if not set.
///
public string PlayFabId;
}
[Serializable]
public class GetCharacterDataResult : PlayFabResultCommon
{
///
/// Unique PlayFab assigned ID for a specific character owned by a user
///
public string CharacterId;
///
/// User specific data for this title.
///
public Dictionary Data;
///
/// Indicates the current version of the data that has been set. This is incremented with every set call for that type of
/// data (read-only, internal, etc). This version can be provided in Get calls to find updated data.
///
public uint DataVersion;
}
///
/// All items currently in the character inventory will be returned, irrespective of how they were acquired (via purchasing,
/// grants, coupons, etc.). Items that are expired, fully consumed, or are no longer valid are not considered to be in the
/// user's current inventory, and so will not be not included. Also returns their virtual currency balances.
///
[Serializable]
public class GetCharacterInventoryRequest : PlayFabRequestCommon
{
///
/// Used to limit results to only those from a specific catalog version.
///
public string CatalogVersion;
///
/// Unique PlayFab assigned ID for a specific character owned by a user
///
public string CharacterId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class GetCharacterInventoryResult : PlayFabResultCommon
{
///
/// Unique identifier of the character for this inventory.
///
public string CharacterId;
///
/// Array of inventory items belonging to the character.
///
public List Inventory;
///
/// Array of virtual currency balance(s) belonging to the character.
///
public Dictionary VirtualCurrency;
///
/// Array of remaining times and timestamps for virtual currencies.
///
public Dictionary VirtualCurrencyRechargeTimes;
}
[Serializable]
public class GetCharacterLeaderboardRequest : PlayFabRequestCommon
{
///
/// Maximum number of entries to retrieve. Default 10, maximum 100.
///
public int? MaxResultsCount;
///
/// First entry in the leaderboard to be retrieved.
///
public int StartPosition;
///
/// Unique identifier for the title-specific statistic for the leaderboard.
///
public string StatisticName;
}
///
/// Note that the Position of the character in the results is for the overall leaderboard.
///
[Serializable]
public class GetCharacterLeaderboardResult : PlayFabResultCommon
{
///
/// Ordered list of leaderboard entries.
///
public List Leaderboard;
}
[Serializable]
public class GetCharacterStatisticsRequest : PlayFabRequestCommon
{
///
/// Unique PlayFab assigned ID for a specific character owned by a user
///
public string CharacterId;
}
///
/// In addition to being available for use by the title, the statistics are used for all leaderboard operations in PlayFab.
///
[Serializable]
public class GetCharacterStatisticsResult : PlayFabResultCommon
{
///
/// The requested character statistics.
///
public Dictionary CharacterStatistics;
}
[Serializable]
public class GetContentDownloadUrlRequest : PlayFabRequestCommon
{
///
/// HTTP method to fetch item - GET or HEAD. Use HEAD when only fetching metadata. Default is GET.
///
public string HttpMethod;
///
/// Key of the content item to fetch, usually formatted as a path, e.g. images/a.png
///
public string Key;
///
/// True to download through CDN. CDN provides higher download bandwidth and lower latency. However, if you want the latest,
/// non-cached version of the content during development, set this to false. Default is true.
///
public bool? ThruCDN;
}
[Serializable]
public class GetContentDownloadUrlResult : PlayFabResultCommon
{
///
/// URL for downloading content via HTTP GET or HEAD method. The URL will expire in approximately one hour.
///
public string URL;
}
[Serializable]
public class GetFriendLeaderboardAroundPlayerRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Indicates which other platforms' friends should be included in the response. In HTTP, it is represented as a
/// comma-separated list of platforms.
///
public ExternalFriendSources? ExternalPlatformFriends;
///
/// Maximum number of entries to retrieve. Default 10, maximum 100.
///
public int? MaxResultsCount;
///
/// PlayFab unique identifier of the user to center the leaderboard around. If null will center on the logged in user.
///
public string PlayFabId;
///
/// If non-null, this determines which properties of the resulting player profiles to return. For API calls from the client,
/// only the allowed client profile properties for the title may be requested. These allowed properties are configured in
/// the Game Manager "Client Profile Options" tab in the "Settings" section.
///
public PlayerProfileViewConstraints ProfileConstraints;
///
/// Statistic used to rank players for this leaderboard.
///
public string StatisticName;
///
/// The version of the leaderboard to get.
///
public int? Version;
///
/// Xbox token if Xbox friends should be included. Requires Xbox be configured on PlayFab.
///
public string XboxToken;
}
///
/// Note: When calling 'GetLeaderboardAround...' APIs, the position of the user defaults to 0 when the user does not have
/// the corresponding statistic.If Facebook friends are included, make sure the access token from previous LoginWithFacebook
/// call is still valid and not expired. If Xbox Live friends are included, make sure the access token from the previous
/// LoginWithXbox call is still valid and not expired.
///
[Serializable]
public class GetFriendLeaderboardAroundPlayerResult : PlayFabResultCommon
{
///
/// Ordered listing of users and their positions in the requested leaderboard.
///
public List Leaderboard;
///
/// The time the next scheduled reset will occur. Null if the leaderboard does not reset on a schedule.
///
public DateTime? NextReset;
///
/// The version of the leaderboard returned.
///
public int Version;
}
[Serializable]
public class GetFriendLeaderboardRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Indicates which other platforms' friends should be included in the response. In HTTP, it is represented as a
/// comma-separated list of platforms.
///
public ExternalFriendSources? ExternalPlatformFriends;
///
/// Maximum number of entries to retrieve. Default 10, maximum 100.
///
public int? MaxResultsCount;
///
/// If non-null, this determines which properties of the resulting player profiles to return. For API calls from the client,
/// only the allowed client profile properties for the title may be requested. These allowed properties are configured in
/// the Game Manager "Client Profile Options" tab in the "Settings" section.
///
public PlayerProfileViewConstraints ProfileConstraints;
///
/// Position in the leaderboard to start this listing (defaults to the first entry).
///
public int StartPosition;
///
/// Statistic used to rank friends for this leaderboard.
///
public string StatisticName;
///
/// The version of the leaderboard to get.
///
public int? Version;
///
/// Xbox token if Xbox friends should be included. Requires Xbox be configured on PlayFab.
///
public string XboxToken;
}
[Serializable]
public class GetFriendsListRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Indicates which other platforms' friends should be included in the response. In HTTP, it is represented as a
/// comma-separated list of platforms.
///
public ExternalFriendSources? ExternalPlatformFriends;
///
/// If non-null, this determines which properties of the resulting player profiles to return. For API calls from the client,
/// only the allowed client profile properties for the title may be requested. These allowed properties are configured in
/// the Game Manager "Client Profile Options" tab in the "Settings" section.
///
public PlayerProfileViewConstraints ProfileConstraints;
///
/// Xbox token if Xbox friends should be included. Requires Xbox be configured on PlayFab.
///
public string XboxToken;
}
///
/// If any additional services are queried for the user's friends, those friends who also have a PlayFab account registered
/// for the title will be returned in the results. For Facebook, user has to have logged into the title's Facebook app
/// recently, and only friends who also plays this game will be included. Note: If the user authenticated with
/// AuthenticationToken when calling LoginWithFacebook, instead of AcessToken, an empty list will be returned. For Xbox
/// Live, user has to have logged into the Xbox Live recently, and only friends who also play this game will be included.
///
[Serializable]
public class GetFriendsListResult : PlayFabResultCommon
{
///
/// Array of friends found.
///
public List Friends;
}
[Serializable]
public class GetLeaderboardAroundCharacterRequest : PlayFabRequestCommon
{
///
/// Unique PlayFab assigned ID for a specific character on which to center the leaderboard.
///
public string CharacterId;
///
/// Maximum number of entries to retrieve. Default 10, maximum 100.
///
public int? MaxResultsCount;
///
/// Unique identifier for the title-specific statistic for the leaderboard.
///
public string StatisticName;
}
///
/// Note: When calling 'GetLeaderboardAround...' APIs, the position of the character defaults to 0 when the character does
/// not have the corresponding statistic.
///
[Serializable]
public class GetLeaderboardAroundCharacterResult : PlayFabResultCommon
{
///
/// Ordered list of leaderboard entries.
///
public List Leaderboard;
}
[Serializable]
public class GetLeaderboardAroundPlayerRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Maximum number of entries to retrieve. Default 10, maximum 100.
///
public int? MaxResultsCount;
///
/// PlayFab unique identifier of the user to center the leaderboard around. If null will center on the logged in user.
///
public string PlayFabId;
///
/// If non-null, this determines which properties of the resulting player profiles to return. For API calls from the client,
/// only the allowed client profile properties for the title may be requested. These allowed properties are configured in
/// the Game Manager "Client Profile Options" tab in the "Settings" section.
///
public PlayerProfileViewConstraints ProfileConstraints;
///
/// Statistic used to rank players for this leaderboard.
///
public string StatisticName;
///
/// The version of the leaderboard to get.
///
public int? Version;
}
///
/// Note: When calling 'GetLeaderboardAround...' APIs, the position of the user defaults to 0 when the user does not have
/// the corresponding statistic.
///
[Serializable]
public class GetLeaderboardAroundPlayerResult : PlayFabResultCommon
{
///
/// Ordered listing of users and their positions in the requested leaderboard.
///
public List Leaderboard;
///
/// The time the next scheduled reset will occur. Null if the leaderboard does not reset on a schedule.
///
public DateTime? NextReset;
///
/// The version of the leaderboard returned.
///
public int Version;
}
[Serializable]
public class GetLeaderboardForUsersCharactersRequest : PlayFabRequestCommon
{
///
/// Unique identifier for the title-specific statistic for the leaderboard.
///
public string StatisticName;
}
///
/// NOTE: The position of the character in the results is relative to the other characters for that specific user. This mean
/// the values will always be between 0 and one less than the number of characters returned regardless of the size of the
/// actual leaderboard.
///
[Serializable]
public class GetLeaderboardForUsersCharactersResult : PlayFabResultCommon
{
///
/// Ordered list of leaderboard entries.
///
public List Leaderboard;
}
[Serializable]
public class GetLeaderboardRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Maximum number of entries to retrieve. Default 10, maximum 100.
///
public int? MaxResultsCount;
///
/// If non-null, this determines which properties of the resulting player profiles to return. For API calls from the client,
/// only the allowed client profile properties for the title may be requested. These allowed properties are configured in
/// the Game Manager "Client Profile Options" tab in the "Settings" section.
///
public PlayerProfileViewConstraints ProfileConstraints;
///
/// Position in the leaderboard to start this listing (defaults to the first entry).
///
public int StartPosition;
///
/// Statistic used to rank players for this leaderboard.
///
public string StatisticName;
///
/// The version of the leaderboard to get.
///
public int? Version;
}
///
/// Note: the user's Position is relative to the overall leaderboard.
///
[Serializable]
public class GetLeaderboardResult : PlayFabResultCommon
{
///
/// Ordered listing of users and their positions in the requested leaderboard.
///
public List Leaderboard;
///
/// The time the next scheduled reset will occur. Null if the leaderboard does not reset on a schedule.
///
public DateTime? NextReset;
///
/// The version of the leaderboard returned.
///
public int Version;
}
[Serializable]
public class GetPaymentTokenRequest : PlayFabRequestCommon
{
///
/// The name of service to provide the payment token. Allowed Values are: xsolla
///
public string TokenProvider;
}
[Serializable]
public class GetPaymentTokenResult : PlayFabResultCommon
{
///
/// PlayFab's purchase order identifier.
///
public string OrderId;
///
/// The token from provider.
///
public string ProviderToken;
}
[Serializable]
public class GetPhotonAuthenticationTokenRequest : PlayFabRequestCommon
{
///
/// The Photon applicationId for the game you wish to log into.
///
public string PhotonApplicationId;
}
[Serializable]
public class GetPhotonAuthenticationTokenResult : PlayFabResultCommon
{
///
/// The Photon authentication token for this game-session.
///
public string PhotonCustomAuthenticationToken;
}
[Serializable]
public class GetPlayerCombinedInfoRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// PlayFabId of the user whose data will be returned. If not filled included, we return the data for the calling player.
///
public string PlayFabId;
}
[Serializable]
public class GetPlayerCombinedInfoRequestParams : PlayFabBaseModel
{
///
/// Whether to get character inventories. Defaults to false.
///
public bool GetCharacterInventories;
///
/// Whether to get the list of characters. Defaults to false.
///
public bool GetCharacterList;
///
/// Whether to get player profile. Defaults to false. Has no effect for a new player.
///
public bool GetPlayerProfile;
///
/// Whether to get player statistics. Defaults to false.
///
public bool GetPlayerStatistics;
///
/// Whether to get title data. Defaults to false.
///
public bool GetTitleData;
///
/// Whether to get the player's account Info. Defaults to false
///
public bool GetUserAccountInfo;
///
/// Whether to get the player's custom data. Defaults to false
///
public bool GetUserData;
///
/// Whether to get the player's inventory. Defaults to false
///
public bool GetUserInventory;
///
/// Whether to get the player's read only data. Defaults to false
///
public bool GetUserReadOnlyData;
///
/// Whether to get the player's virtual currency balances. Defaults to false
///
public bool GetUserVirtualCurrency;
///
/// Specific statistics to retrieve. Leave null to get all keys. Has no effect if GetPlayerStatistics is false
///
public List PlayerStatisticNames;
///
/// Specifies the properties to return from the player profile. Defaults to returning the player's display name.
///
public PlayerProfileViewConstraints ProfileConstraints;
///
/// Specific keys to search for in the custom data. Leave null to get all keys. Has no effect if GetTitleData is false
///
public List TitleDataKeys;
///
/// Specific keys to search for in the custom data. Leave null to get all keys. Has no effect if GetUserData is false
///
public List UserDataKeys;
///
/// Specific keys to search for in the custom data. Leave null to get all keys. Has no effect if GetUserReadOnlyData is
/// false
///
public List UserReadOnlyDataKeys;
}
///
/// Returns whatever info is requested in the response for the user. If no user is explicitly requested this defaults to the
/// authenticated user. If the user is the same as the requester, PII (like email address, facebook id) is returned if
/// available. Otherwise, only public information is returned. All parameters default to false.
///
[Serializable]
public class GetPlayerCombinedInfoResult : PlayFabResultCommon
{
///
/// Results for requested info.
///
public GetPlayerCombinedInfoResultPayload InfoResultPayload;
///
/// Unique PlayFab assigned ID of the user on whom the operation will be performed.
///
public string PlayFabId;
}
[Serializable]
public class GetPlayerCombinedInfoResultPayload : PlayFabBaseModel
{
///
/// Account information for the user. This is always retrieved.
///
public UserAccountInfo AccountInfo;
///
/// Inventories for each character for the user.
///
public List CharacterInventories;
///
/// List of characters for the user.
///
public List CharacterList;
///
/// The profile of the players. This profile is not guaranteed to be up-to-date. For a new player, this profile will not
/// exist.
///
public PlayerProfileModel PlayerProfile;
///
/// List of statistics for this player.
///
public List PlayerStatistics;
///
/// Title data for this title.
///
public Dictionary TitleData;
///
/// User specific custom data.
///
public Dictionary UserData;
///
/// The version of the UserData that was returned.
///
public uint UserDataVersion;
///
/// Array of inventory items in the user's current inventory.
///
public List UserInventory;
///
/// User specific read-only data.
///
public Dictionary UserReadOnlyData;
///
/// The version of the Read-Only UserData that was returned.
///
public uint UserReadOnlyDataVersion;
///
/// Dictionary of virtual currency balance(s) belonging to the user.
///
public Dictionary UserVirtualCurrency;
///
/// Dictionary of remaining times and timestamps for virtual currencies.
///
public Dictionary UserVirtualCurrencyRechargeTimes;
}
///
/// This API allows for access to details regarding a user in the PlayFab service, usually for purposes of customer support.
/// Note that data returned may be Personally Identifying Information (PII), such as email address, and so care should be
/// taken in how this data is stored and managed. Since this call will always return the relevant information for users who
/// have accessed the title, the recommendation is to not store this data locally.
///
[Serializable]
public class GetPlayerProfileRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Unique PlayFab assigned ID of the user on whom the operation will be performed.
///
public string PlayFabId;
///
/// If non-null, this determines which properties of the resulting player profiles to return. For API calls from the client,
/// only the allowed client profile properties for the title may be requested. These allowed properties are configured in
/// the Game Manager "Client Profile Options" tab in the "Settings" section.
///
public PlayerProfileViewConstraints ProfileConstraints;
}
[Serializable]
public class GetPlayerProfileResult : PlayFabResultCommon
{
///
/// The profile of the player. This profile is not guaranteed to be up-to-date. For a new player, this profile will not
/// exist.
///
public PlayerProfileModel PlayerProfile;
}
[Serializable]
public class GetPlayerSegmentsRequest : PlayFabRequestCommon
{
}
[Serializable]
public class GetPlayerSegmentsResult : PlayFabResultCommon
{
///
/// Array of segments the requested player currently belongs to.
///
public List Segments;
}
[Serializable]
public class GetPlayerStatisticsRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// statistics to return (current version will be returned for each)
///
public List StatisticNames;
///
/// statistics to return, if StatisticNames is not set (only statistics which have a version matching that provided will be
/// returned)
///
public List StatisticNameVersions;
}
///
/// In addition to being available for use by the title, the statistics are used for all leaderboard operations in PlayFab.
///
[Serializable]
public class GetPlayerStatisticsResult : PlayFabResultCommon
{
///
/// User statistics for the requested user.
///
public List Statistics;
}
[Serializable]
public class GetPlayerStatisticVersionsRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// unique name of the statistic
///
public string StatisticName;
}
[Serializable]
public class GetPlayerStatisticVersionsResult : PlayFabResultCommon
{
///
/// version change history of the statistic
///
public List StatisticVersions;
}
///
/// This API will return a list of canonical tags which includes both namespace and tag's name. If namespace is not
/// provided, the result is a list of all canonical tags. TagName can be used for segmentation and Namespace is limited to
/// 128 characters.
///
[Serializable]
public class GetPlayerTagsRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Optional namespace to filter results by
///
public string Namespace;
///
/// Unique PlayFab assigned ID of the user on whom the operation will be performed.
///
public string PlayFabId;
}
[Serializable]
public class GetPlayerTagsResult : PlayFabResultCommon
{
///
/// Unique PlayFab assigned ID of the user on whom the operation will be performed.
///
public string PlayFabId;
///
/// Canonical tags (including namespace and tag's name) for the requested user
///
public List Tags;
}
[Serializable]
public class GetPlayerTradesRequest : PlayFabRequestCommon
{
///
/// Returns only trades with the given status. If null, returns all trades.
///
public TradeStatus? StatusFilter;
}
[Serializable]
public class GetPlayerTradesResponse : PlayFabResultCommon
{
///
/// History of trades which this player has accepted.
///
public List AcceptedTrades;
///
/// The trades for this player which are currently available to be accepted.
///
public List OpenedTrades;
}
[Serializable]
public class GetPlayFabIDsFromFacebookIDsRequest : PlayFabRequestCommon
{
///
/// Array of unique Facebook identifiers for which the title needs to get PlayFab identifiers. The array cannot exceed 2,000
/// in length.
///
public List FacebookIDs;
}
///
/// For Facebook identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromFacebookIDsResult : PlayFabResultCommon
{
///
/// Mapping of Facebook identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromFacebookInstantGamesIdsRequest : PlayFabRequestCommon
{
///
/// Array of unique Facebook Instant Games identifiers for which the title needs to get PlayFab identifiers. The array
/// cannot exceed 25 in length.
///
public List FacebookInstantGamesIds;
}
///
/// For Facebook Instant Game identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromFacebookInstantGamesIdsResult : PlayFabResultCommon
{
///
/// Mapping of Facebook Instant Games identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromGameCenterIDsRequest : PlayFabRequestCommon
{
///
/// Array of unique Game Center identifiers (the Player Identifier) for which the title needs to get PlayFab identifiers.
/// The array cannot exceed 2,000 in length.
///
public List GameCenterIDs;
}
///
/// For Game Center identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromGameCenterIDsResult : PlayFabResultCommon
{
///
/// Mapping of Game Center identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromGenericIDsRequest : PlayFabRequestCommon
{
///
/// Array of unique generic service identifiers for which the title needs to get PlayFab identifiers. Currently limited to a
/// maximum of 10 in a single request.
///
public List GenericIDs;
}
///
/// For generic service identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromGenericIDsResult : PlayFabResultCommon
{
///
/// Mapping of generic service identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromGoogleIDsRequest : PlayFabRequestCommon
{
///
/// Array of unique Google identifiers (Google+ user IDs) for which the title needs to get PlayFab identifiers. The array
/// cannot exceed 2,000 in length.
///
public List GoogleIDs;
}
///
/// For Google identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromGoogleIDsResult : PlayFabResultCommon
{
///
/// Mapping of Google identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromGooglePlayGamesPlayerIDsRequest : PlayFabRequestCommon
{
///
/// Array of unique Google Play Games identifiers (Google+ user IDs) for which the title needs to get PlayFab identifiers.
/// The array cannot exceed 2,000 in length.
///
public List GooglePlayGamesPlayerIDs;
}
///
/// For Google Play Games identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromGooglePlayGamesPlayerIDsResult : PlayFabResultCommon
{
///
/// Mapping of Google Play Games identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromKongregateIDsRequest : PlayFabRequestCommon
{
///
/// Array of unique Kongregate identifiers (Kongregate's user_id) for which the title needs to get PlayFab identifiers. The
/// array cannot exceed 2,000 in length.
///
public List KongregateIDs;
}
///
/// For Kongregate identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromKongregateIDsResult : PlayFabResultCommon
{
///
/// Mapping of Kongregate identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromNintendoServiceAccountIdsRequest : PlayFabRequestCommon
{
///
/// Array of unique Nintendo Switch Account identifiers for which the title needs to get PlayFab identifiers. The array
/// cannot exceed 2,000 in length.
///
public List NintendoAccountIds;
}
///
/// For Nintendo Service Account identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromNintendoServiceAccountIdsResult : PlayFabResultCommon
{
///
/// Mapping of Nintendo Switch Service Account identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromNintendoSwitchDeviceIdsRequest : PlayFabRequestCommon
{
///
/// Array of unique Nintendo Switch Device identifiers for which the title needs to get PlayFab identifiers. The array
/// cannot exceed 2,000 in length.
///
public List NintendoSwitchDeviceIds;
}
///
/// For Nintendo Switch identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromNintendoSwitchDeviceIdsResult : PlayFabResultCommon
{
///
/// Mapping of Nintendo Switch Device identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromPSNAccountIDsRequest : PlayFabRequestCommon
{
///
/// Id of the PlayStation :tm: Network issuer environment. If null, defaults to production environment.
///
public int? IssuerId;
///
/// Array of unique PlayStation :tm: Network identifiers for which the title needs to get PlayFab identifiers. The array
/// cannot exceed 2,000 in length.
///
public List PSNAccountIDs;
}
///
/// For PlayStation :tm: Network identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromPSNAccountIDsResult : PlayFabResultCommon
{
///
/// Mapping of PlayStation :tm: Network identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromPSNOnlineIDsRequest : PlayFabRequestCommon
{
///
/// Id of the PlayStation :tm: Network issuer environment. If null, defaults to production environment.
///
public int? IssuerId;
///
/// Array of unique PlayStation :tm: Network identifiers for which the title needs to get PlayFab identifiers. The array
/// cannot exceed 2,000 in length.
///
public List PSNOnlineIDs;
}
///
/// For PlayStation :tm: Network identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromPSNOnlineIDsResult : PlayFabResultCommon
{
///
/// Mapping of PlayStation :tm: Network identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromSteamIDsRequest : PlayFabRequestCommon
{
///
/// Array of unique Steam identifiers (Steam profile IDs) for which the title needs to get PlayFab identifiers. The array
/// cannot exceed 2,000 in length.
///
public List SteamStringIDs;
}
///
/// For Steam identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromSteamIDsResult : PlayFabResultCommon
{
///
/// Mapping of Steam identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromTwitchIDsRequest : PlayFabRequestCommon
{
///
/// Array of unique Twitch identifiers (Twitch's _id) for which the title needs to get PlayFab identifiers. The array cannot
/// exceed 2,000 in length.
///
public List TwitchIds;
}
///
/// For Twitch identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromTwitchIDsResult : PlayFabResultCommon
{
///
/// Mapping of Twitch identifiers to PlayFab identifiers.
///
public List Data;
}
[Serializable]
public class GetPlayFabIDsFromXboxLiveIDsRequest : PlayFabRequestCommon
{
///
/// The ID of Xbox Live sandbox.
///
public string Sandbox;
///
/// Array of unique Xbox Live account identifiers for which the title needs to get PlayFab identifiers. The array cannot
/// exceed 2,000 in length.
///
public List XboxLiveAccountIDs;
}
///
/// For XboxLive identifiers which have not been linked to PlayFab accounts, null will be returned.
///
[Serializable]
public class GetPlayFabIDsFromXboxLiveIDsResult : PlayFabResultCommon
{
///
/// Mapping of Xbox Live identifiers to PlayFab identifiers.
///
public List Data;
}
///
/// This API is designed to return publisher-specific values which can be read, but not written to, by the client. This data
/// is shared across all titles assigned to a particular publisher, and can be used for cross-game coordination. Only titles
/// assigned to a publisher can use this API. For more information email helloplayfab@microsoft.com. Note that there may up
/// to a minute delay in between updating title data and this API call returning the newest value.
///
[Serializable]
public class GetPublisherDataRequest : PlayFabRequestCommon
{
///
/// array of keys to get back data from the Publisher data blob, set by the admin tools
///
public List Keys;
}
[Serializable]
public class GetPublisherDataResult : PlayFabResultCommon
{
///
/// a dictionary object of key / value pairs
///
public Dictionary Data;
}
[Serializable]
public class GetPurchaseRequest : PlayFabRequestCommon
{
///
/// Purchase order identifier.
///
public string OrderId;
}
[Serializable]
public class GetPurchaseResult : PlayFabResultCommon
{
///
/// Purchase order identifier.
///
public string OrderId;
///
/// Payment provider used for transaction (If not VC)
///
public string PaymentProvider;
///
/// Date and time of the purchase.
///
public DateTime PurchaseDate;
///
/// Provider transaction ID (If not VC)
///
public string TransactionId;
///
/// PlayFab transaction status
///
public string TransactionStatus;
}
[Serializable]
public class GetSegmentResult : PlayFabBaseModel
{
///
/// Identifier of the segments AB Test, if it is attached to one.
///
public string ABTestParent;
///
/// Unique identifier for this segment.
///
public string Id;
///
/// Segment name.
///
public string Name;
}
[Serializable]
public class GetSharedGroupDataRequest : PlayFabRequestCommon
{
///
/// If true, return the list of all members of the shared group.
///
public bool? GetMembers;
///
/// Specific keys to retrieve from the shared group (if not specified, all keys will be returned, while an empty array
/// indicates that no keys should be returned).
///
public List Keys;
///
/// Unique identifier for the shared group.
///
public string SharedGroupId;
}
[Serializable]
public class GetSharedGroupDataResult : PlayFabResultCommon
{
///
/// Data for the requested keys.
///
public Dictionary Data;
///
/// List of PlayFabId identifiers for the members of this group, if requested.
///
public List Members;
}
///
/// A store contains an array of references to items defined in one or more catalog versions of the game, along with the
/// prices for the item, in both real world and virtual currencies. These prices act as an override to any prices defined in
/// the catalog. In this way, the base definitions of the items may be defined in the catalog, with all associated
/// properties, while the pricing can be set for each store, as needed. This allows for subsets of goods to be defined for
/// different purposes (in order to simplify showing some, but not all catalog items to users, based upon different
/// characteristics), along with unique prices. Note that all prices defined in the catalog and store definitions for the
/// item are considered valid, and that a compromised client can be made to send a request for an item based upon any of
/// these definitions. If no price is specified in the store for an item, the price set in the catalog should be displayed
/// to the user.
///
[Serializable]
public class GetStoreItemsRequest : PlayFabRequestCommon
{
///
/// Catalog version to store items from. Use default catalog version if null
///
public string CatalogVersion;
///
/// Unqiue identifier for the store which is being requested.
///
public string StoreId;
}
[Serializable]
public class GetStoreItemsResult : PlayFabResultCommon
{
///
/// The base catalog that this store is a part of.
///
public string CatalogVersion;
///
/// Additional data about the store.
///
public StoreMarketingModel MarketingData;
///
/// How the store was last updated (Admin or a third party).
///
public SourceType? Source;
///
/// Array of items which can be purchased from this store.
///
public List Store;
///
/// The ID of this store.
///
public string StoreId;
}
///
/// This query retrieves the current time from one of the servers in PlayFab. Please note that due to clock drift between
/// servers, there is a potential variance of up to 5 seconds.
///
[Serializable]
public class GetTimeRequest : PlayFabRequestCommon
{
}
///
/// Time is always returned as Coordinated Universal Time (UTC).
///
[Serializable]
public class GetTimeResult : PlayFabResultCommon
{
///
/// Current server time when the request was received, in UTC
///
public DateTime Time;
}
///
/// This API is designed to return title specific values which can be read, but not written to, by the client. For example,
/// a developer could choose to store values which modify the user experience, such as enemy spawn rates, weapon strengths,
/// movement speeds, etc. This allows a developer to update the title without the need to create, test, and ship a new
/// build. If the player belongs to an experiment variant that uses title data overrides, the overrides are applied
/// automatically and returned with the title data. Note that there may up to a minute delay in between updating title data
/// and this API call returning the newest value.
///
[Serializable]
public class GetTitleDataRequest : PlayFabRequestCommon
{
///
/// Specific keys to search for in the title data (leave null to get all keys)
///
public List Keys;
///
/// Optional field that specifies the name of an override. This value is ignored when used by the game client; otherwise,
/// the overrides are applied automatically to the title data.
///
public string OverrideLabel;
}
[Serializable]
public class GetTitleDataResult : PlayFabResultCommon
{
///
/// a dictionary object of key / value pairs
///
public Dictionary Data;
}
[Serializable]
public class GetTitleNewsRequest : PlayFabRequestCommon
{
///
/// Limits the results to the last n entries. Defaults to 10 if not set.
///
public int? Count;
}
[Serializable]
public class GetTitleNewsResult : PlayFabResultCommon
{
///
/// Array of news items.
///
public List News;
}
///
/// An RSA CSP blob to be used to encrypt the payload of account creation requests when that API requires a signature
/// header. For example if Client/LoginWithCustomId requires signature headers but the player does not have an account yet
/// follow these steps: 1) Call Client/GetTitlePublicKey with one of the title's shared secrets. 2) Convert the Base64
/// encoded CSP blob to a byte array and create an RSA signing object. 3) Encrypt the UTF8 encoded JSON body of the
/// registration request and place the Base64 encoded result into the EncryptedRequest and with the TitleId field, all other
/// fields can be left empty when performing the API request. 4) Client receives authentication token as normal. Future
/// requests to LoginWithCustomId will require the X-PlayFab-Signature header.
///
[Serializable]
public class GetTitlePublicKeyRequest : PlayFabRequestCommon
{
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
///
/// The shared secret key for this title
///
public string TitleSharedSecret;
}
[Serializable]
public class GetTitlePublicKeyResult : PlayFabResultCommon
{
///
/// Base64 encoded RSA CSP byte array blob containing the title's public RSA key
///
public string RSAPublicKey;
}
[Serializable]
public class GetTradeStatusRequest : PlayFabRequestCommon
{
///
/// Player who opened trade.
///
public string OfferingPlayerId;
///
/// Trade identifier as returned by OpenTradeOffer.
///
public string TradeId;
}
[Serializable]
public class GetTradeStatusResponse : PlayFabResultCommon
{
///
/// Information about the requested trade.
///
public TradeInfo Trade;
}
///
/// Data is stored as JSON key-value pairs. Every time the data is updated via any source, the version counter is
/// incremented. If the Version parameter is provided, then this call will only return data if the current version on the
/// system is greater than the value provided. If the Keys parameter is provided, the data object returned will only contain
/// the data specific to the indicated Keys. Otherwise, the full set of custom user data will be returned.
///
[Serializable]
public class GetUserDataRequest : PlayFabRequestCommon
{
///
/// The version that currently exists according to the caller. The call will return the data for all of the keys if the
/// version in the system is greater than this.
///
public uint? IfChangedFromDataVersion;
///
/// List of unique keys to load from.
///
public List Keys;
///
/// Unique PlayFab identifier of the user to load data for. Optional, defaults to yourself if not set. When specified to a
/// PlayFab id of another player, then this will only return public keys for that account.
///
public string PlayFabId;
}
[Serializable]
public class GetUserDataResult : PlayFabResultCommon
{
///
/// User specific data for this title.
///
public Dictionary Data;
///
/// Indicates the current version of the data that has been set. This is incremented with every set call for that type of
/// data (read-only, internal, etc). This version can be provided in Get calls to find updated data.
///
public uint DataVersion;
}
[Serializable]
public class GetUserInventoryRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
///
/// All items currently in the user inventory will be returned, irrespective of how they were acquired (via purchasing,
/// grants, coupons, etc.). Items that are expired, fully consumed, or are no longer valid are not considered to be in the
/// user's current inventory, and so will not be not included.
///
[Serializable]
public class GetUserInventoryResult : PlayFabResultCommon
{
///
/// Array of inventory items belonging to the user.
///
public List Inventory;
///
/// Array of virtual currency balance(s) belonging to the user.
///
public Dictionary VirtualCurrency;
///
/// Array of remaining times and timestamps for virtual currencies.
///
public Dictionary VirtualCurrencyRechargeTimes;
}
[Serializable]
public class GooglePlayFabIdPair : PlayFabBaseModel
{
///
/// Unique Google identifier for a user.
///
public string GoogleId;
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the Google identifier.
///
public string PlayFabId;
}
[Serializable]
public class GooglePlayGamesPlayFabIdPair : PlayFabBaseModel
{
///
/// Unique Google Play Games identifier for a user.
///
public string GooglePlayGamesPlayerId;
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the Google Play Games identifier.
///
public string PlayFabId;
}
///
/// Grants a character to the user of the type specified by the item ID. The user must already have an instance of this item
/// in their inventory in order to allow character creation. This item can come from a purchase or grant, which must be done
/// before calling to create the character.
///
[Serializable]
public class GrantCharacterToUserRequest : PlayFabRequestCommon
{
///
/// Catalog version from which items are to be granted.
///
public string CatalogVersion;
///
/// Non-unique display name of the character being granted (1-40 characters in length).
///
public string CharacterName;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Catalog item identifier of the item in the user's inventory that corresponds to the character in the catalog to be
/// created.
///
public string ItemId;
}
[Serializable]
public class GrantCharacterToUserResult : PlayFabResultCommon
{
///
/// Unique identifier tagged to this character.
///
public string CharacterId;
///
/// Type of character that was created.
///
public string CharacterType;
///
/// Indicates whether this character was created successfully.
///
public bool Result;
}
///
/// A unique instance of an item in a user's inventory. Note, to retrieve additional information for an item such as Tags,
/// Description that are the same across all instances of the item, a call to GetCatalogItems is required. The ItemID of can
/// be matched to a catalog entry, which contains the additional information. Also note that Custom Data is only set when
/// the User's specific instance has updated the CustomData via a call to UpdateUserInventoryItemCustomData. Other fields
/// such as UnitPrice and UnitCurrency are only set when the item was granted via a purchase.
///
[Serializable]
public class ItemInstance : PlayFabBaseModel
{
///
/// Game specific comment associated with this instance when it was added to the user inventory.
///
public string Annotation;
///
/// Array of unique items that were awarded when this catalog item was purchased.
///
public List BundleContents;
///
/// Unique identifier for the parent inventory item, as defined in the catalog, for object which were added from a bundle or
/// container.
///
public string BundleParent;
///
/// Catalog version for the inventory item, when this instance was created.
///
public string CatalogVersion;
///
/// A set of custom key-value pairs on the instance of the inventory item, which is not to be confused with the catalog
/// item's custom data.
///
public Dictionary CustomData;
///
/// CatalogItem.DisplayName at the time this item was purchased.
///
public string DisplayName;
///
/// Timestamp for when this instance will expire.
///
public DateTime? Expiration;
///
/// Class name for the inventory item, as defined in the catalog.
///
public string ItemClass;
///
/// Unique identifier for the inventory item, as defined in the catalog.
///
public string ItemId;
///
/// Unique item identifier for this specific instance of the item.
///
public string ItemInstanceId;
///
/// Timestamp for when this instance was purchased.
///
public DateTime? PurchaseDate;
///
/// Total number of remaining uses, if this is a consumable item.
///
public int? RemainingUses;
///
/// Currency type for the cost of the catalog item. Not available when granting items.
///
public string UnitCurrency;
///
/// Cost of the catalog item in the given currency. Not available when granting items.
///
public uint UnitPrice;
///
/// The number of uses that were added or removed to this item in this call.
///
public int? UsesIncrementedBy;
}
[Serializable]
public class ItemPurchaseRequest : PlayFabBaseModel
{
///
/// Title-specific text concerning this purchase.
///
public string Annotation;
///
/// Unique ItemId of the item to purchase.
///
public string ItemId;
///
/// How many of this item to purchase. Min 1, maximum 25.
///
public uint Quantity;
///
/// Items to be upgraded as a result of this purchase (upgraded items are hidden, as they are "replaced" by the new items).
///
public List UpgradeFromItems;
}
[Serializable]
public class KongregatePlayFabIdPair : PlayFabBaseModel
{
///
/// Unique Kongregate identifier for a user.
///
public string KongregateId;
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the Kongregate identifier.
///
public string PlayFabId;
}
[Serializable]
public class LinkAndroidDeviceIDRequest : PlayFabRequestCommon
{
///
/// Specific model of the user's device.
///
public string AndroidDevice;
///
/// Android device identifier for the user's device.
///
public string AndroidDeviceId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the device, unlink the other user and re-link.
///
public bool? ForceLink;
///
/// Specific Operating System version for the user's device.
///
public string OS;
}
[Serializable]
public class LinkAndroidDeviceIDResult : PlayFabResultCommon
{
}
[Serializable]
public class LinkAppleRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to a specific Apple account, unlink the other user and re-link.
///
public bool? ForceLink;
///
/// The JSON Web token (JWT) returned by Apple after login. Represented as the identityToken field in the authorization
/// credential payload. Used to validate the request and find the user ID (Apple subject) to link with.
///
public string IdentityToken;
}
[Serializable]
public class LinkCustomIDRequest : PlayFabRequestCommon
{
///
/// Custom unique identifier for the user, generated by the title.
///
public string CustomId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the custom ID, unlink the other user and re-link.
///
public bool? ForceLink;
}
[Serializable]
public class LinkCustomIDResult : PlayFabResultCommon
{
}
[Serializable]
public class LinkedPlatformAccountModel : PlayFabBaseModel
{
///
/// Linked account email of the user on the platform, if available
///
public string Email;
///
/// Authentication platform
///
public LoginIdentityProvider? Platform;
///
/// Unique account identifier of the user on the platform
///
public string PlatformUserId;
///
/// Linked account username of the user on the platform, if available
///
public string Username;
}
///
/// Facebook sign-in is accomplished using the Facebook User Access Token. More information on the Token can be found in the
/// Facebook developer documentation (https://developers.facebook.com/docs/facebook-login/access-tokens/). In Unity, for
/// example, the Token is available as AccessToken in the Facebook SDK ScriptableObject FB. Note that titles should never
/// re-use the same Facebook applications between PlayFab Title IDs, as Facebook provides unique user IDs per application
/// and doing so can result in issues with the Facebook ID for the user in their PlayFab account information. If you must
/// re-use an application in a new PlayFab Title ID, please be sure to first unlink all accounts from Facebook, or delete
/// all users in the first Title ID.
///
[Serializable]
public class LinkFacebookAccountRequest : PlayFabRequestCommon
{
///
/// Unique identifier from Facebook for the user.
///
public string AccessToken;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the account, unlink the other user and re-link.
///
public bool? ForceLink;
}
[Serializable]
public class LinkFacebookAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class LinkFacebookInstantGamesIdRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Facebook Instant Games signature for the user.
///
public string FacebookInstantGamesSignature;
///
/// If another user is already linked to the Facebook Instant Games ID, unlink the other user and re-link.
///
public bool? ForceLink;
}
[Serializable]
public class LinkFacebookInstantGamesIdResult : PlayFabResultCommon
{
}
[Serializable]
public class LinkGameCenterAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the account, unlink the other user and re-link. If the current user is already
/// linked, link both accounts
///
public bool? ForceLink;
///
/// Game Center identifier for the player account to be linked.
///
public string GameCenterId;
///
/// The URL for the public encryption key that will be used to verify the signature.
///
public string PublicKeyUrl;
///
/// A random value used to compute the hash and keep it randomized.
///
public string Salt;
///
/// The verification signature of the authentication payload.
///
public string Signature;
///
/// The integer representation of date and time that the signature was created on. PlayFab will reject authentication
/// signatures not within 10 minutes of the server's current time.
///
public string Timestamp;
}
[Serializable]
public class LinkGameCenterAccountResult : PlayFabResultCommon
{
}
///
/// Google sign-in is accomplished by obtaining a Google OAuth 2.0 credential using the Google sign-in for Android APIs on
/// the device and passing it to this API.
///
[Serializable]
public class LinkGoogleAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the account, unlink the other user and re-link. If the current user is already
/// linked, link both accounts
///
public bool? ForceLink;
///
/// Server authentication code obtained on the client by calling getServerAuthCode()
/// (https://developers.google.com/identity/sign-in/android/offline-access) from Google Play for the user.
///
public string ServerAuthCode;
}
[Serializable]
public class LinkGoogleAccountResult : PlayFabResultCommon
{
}
///
/// Google Play Games sign-in is accomplished by obtaining a Google OAuth 2.0 credential using the Google Play Games sign-in
/// for Android APIs on the device and passing it to this API.
///
[Serializable]
public class LinkGooglePlayGamesServicesAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the account, unlink the other user and re-link. If the current user is already
/// linked, link both accounts
///
public bool? ForceLink;
///
/// OAuth 2.0 server authentication code obtained on the client by calling the requestServerSideAccess()
/// (https://developers.google.com/games/services/android/signin) Google Play Games client API.
///
public string ServerAuthCode;
}
[Serializable]
public class LinkGooglePlayGamesServicesAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class LinkIOSDeviceIDRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Vendor-specific iOS identifier for the user's device.
///
public string DeviceId;
///
/// Specific model of the user's device.
///
public string DeviceModel;
///
/// If another user is already linked to the device, unlink the other user and re-link.
///
public bool? ForceLink;
///
/// Specific Operating System version for the user's device.
///
public string OS;
}
[Serializable]
public class LinkIOSDeviceIDResult : PlayFabResultCommon
{
}
[Serializable]
public class LinkKongregateAccountRequest : PlayFabRequestCommon
{
///
/// Valid session auth ticket issued by Kongregate
///
public string AuthTicket;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the account, unlink the other user and re-link.
///
public bool? ForceLink;
///
/// Numeric user ID assigned by Kongregate
///
public string KongregateId;
}
[Serializable]
public class LinkKongregateAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class LinkNintendoServiceAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to a specific Nintendo Switch account, unlink the other user and re-link.
///
public bool? ForceLink;
///
/// The JSON Web token (JWT) returned by Nintendo after login. Used to validate the request and find the user ID (Nintendo
/// Switch subject) to link with.
///
public string IdentityToken;
}
[Serializable]
public class LinkNintendoSwitchDeviceIdRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the Nintendo Switch Device ID, unlink the other user and re-link.
///
public bool? ForceLink;
///
/// Nintendo Switch unique identifier for the user's device.
///
public string NintendoSwitchDeviceId;
}
[Serializable]
public class LinkNintendoSwitchDeviceIdResult : PlayFabResultCommon
{
}
[Serializable]
public class LinkOpenIdConnectRequest : PlayFabRequestCommon
{
///
/// A name that identifies which configured OpenID Connect provider relationship to use. Maximum 100 characters.
///
public string ConnectionId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to a specific OpenId Connect user, unlink the other user and re-link.
///
public bool? ForceLink;
///
/// The JSON Web token (JWT) returned by the identity provider after login. Represented as the id_token field in the
/// identity provider's response. Used to validate the request and find the user ID (OpenID Connect subject) to link with.
///
public string IdToken;
}
[Serializable]
public class LinkPSNAccountRequest : PlayFabRequestCommon
{
///
/// Authentication code provided by the PlayStation :tm: Network.
///
public string AuthCode;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the account, unlink the other user and re-link.
///
public bool? ForceLink;
///
/// Id of the PlayStation :tm: Network issuer environment. If null, defaults to production environment.
///
public int? IssuerId;
///
/// Redirect URI supplied to PlayStation :tm: Network when requesting an auth code
///
public string RedirectUri;
}
[Serializable]
public class LinkPSNAccountResult : PlayFabResultCommon
{
}
///
/// Steam authentication is accomplished with the Steam Session Ticket. More information on the Ticket can be found in the
/// Steamworks SDK, here: https://partner.steamgames.com/documentation/auth (requires sign-in). NOTE: For Steam
/// authentication to work, the title must be configured with the Steam Application ID and Publisher Key in the PlayFab Game
/// Manager (under Properties). Information on creating a Publisher Key (referred to as the Secret Key in PlayFab) for your
/// title can be found here: https://partner.steamgames.com/documentation/webapi#publisherkey.
///
[Serializable]
public class LinkSteamAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the account, unlink the other user and re-link.
///
public bool? ForceLink;
///
/// Authentication token for the user, returned as a byte array from Steam, and converted to a string (for example, the byte
/// 0x08 should become "08").
///
public string SteamTicket;
///
/// True if ticket was generated using ISteamUser::GetAuthTicketForWebAPI() using "AzurePlayFab" as the identity string.
/// False if the ticket was generated with ISteamUser::GetAuthSessionTicket().
///
public bool? TicketIsServiceSpecific;
}
[Serializable]
public class LinkSteamAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class LinkTwitchAccountRequest : PlayFabRequestCommon
{
///
/// Valid token issued by Twitch
///
public string AccessToken;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the account, unlink the other user and re-link.
///
public bool? ForceLink;
}
[Serializable]
public class LinkTwitchAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class LinkXboxAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// If another user is already linked to the account, unlink the other user and re-link.
///
public bool? ForceLink;
///
/// Token provided by the Xbox Live SDK/XDK method GetTokenAndSignatureAsync("POST", "https://playfabapi.com/", "").
///
public string XboxToken;
}
[Serializable]
public class LinkXboxAccountResult : PlayFabResultCommon
{
}
///
/// Returns a list of every character that currently belongs to a user.
///
[Serializable]
public class ListUsersCharactersRequest : PlayFabRequestCommon
{
///
/// Unique PlayFab assigned ID of the user on whom the operation will be performed.
///
public string PlayFabId;
}
[Serializable]
public class ListUsersCharactersResult : PlayFabResultCommon
{
///
/// The requested list of characters.
///
public List Characters;
}
[Serializable]
public class LocationModel : PlayFabBaseModel
{
///
/// City name.
///
public string City;
///
/// The two-character continent code for this location
///
public ContinentCode? ContinentCode;
///
/// The two-character ISO 3166-1 country code for the country associated with the location
///
public CountryCode? CountryCode;
///
/// Latitude coordinate of the geographic location.
///
public double? Latitude;
///
/// Longitude coordinate of the geographic location.
///
public double? Longitude;
}
public enum LoginIdentityProvider
{
Unknown,
PlayFab,
Custom,
GameCenter,
GooglePlay,
Steam,
XBoxLive,
PSN,
Kongregate,
Facebook,
IOSDevice,
AndroidDevice,
Twitch,
WindowsHello,
GameServer,
CustomServer,
NintendoSwitch,
FacebookInstantGames,
OpenIdConnect,
Apple,
NintendoSwitchAccount,
GooglePlayGames,
XboxMobileStore,
King
}
[Serializable]
public class LoginResult : PlayFabLoginResultCommon
{
///
/// If LoginTitlePlayerAccountEntity flag is set on the login request the title_player_account will also be logged in and
/// returned.
///
public EntityTokenResponse EntityToken;
///
/// Results for requested info.
///
public GetPlayerCombinedInfoResultPayload InfoResultPayload;
///
/// The time of this user's previous login. If there was no previous login, then it's DateTime.MinValue
///
public DateTime? LastLoginTime;
///
/// True if the account was newly created on this login.
///
public bool NewlyCreated;
///
/// Player's unique PlayFabId.
///
public string PlayFabId;
///
/// Unique token authorizing the user and game at the server level, for the current session.
///
public string SessionTicket;
///
/// Settings specific to this user.
///
public UserSettings SettingsForUser;
///
/// The experimentation treatments for this user at the time of login.
///
public TreatmentAssignment TreatmentAssignment;
}
///
/// On Android devices, the recommendation is to use the Settings.Secure.ANDROID_ID as the AndroidDeviceId, as described in
/// this blog post (http://android-developers.blogspot.com/2011/03/identifying-app-installations.html). More information on
/// this identifier can be found in the Android documentation
/// (http://developer.android.com/reference/android/provider/Settings.Secure.html). If this is the first time a user has
/// signed in with the Android device and CreateAccount is set to true, a new PlayFab account will be created and linked to
/// the Android device ID. In this case, no email or username will be associated with the PlayFab account. Otherwise, if no
/// PlayFab account is linked to the Android device, an error indicating this will be returned, so that the title can guide
/// the user through creation of a PlayFab account. Please note that while multiple devices of this type can be linked to a
/// single user account, only the one most recently used to login (or most recently linked) will be reflected in the user's
/// account information. We will be updating to show all linked devices in a future release.
///
[Serializable]
public class LoginWithAndroidDeviceIDRequest : PlayFabRequestCommon
{
///
/// Specific model of the user's device.
///
public string AndroidDevice;
///
/// Android device identifier for the user's device.
///
public string AndroidDeviceId;
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Specific Operating System version for the user's device.
///
public string OS;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
[Serializable]
public class LoginWithAppleRequest : PlayFabRequestCommon
{
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// The JSON Web token (JWT) returned by Apple after login. Represented as the identityToken field in the authorization
/// credential payload. If you choose to ignore the expiration date for identity tokens, you will receive an NotAuthorized
/// error if Apple rotates the signing key. In this case, users have to login to provide a fresh identity token.
///
public string IdentityToken;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// It is highly recommended that developers ensure that it is extremely unlikely that a customer could generate an ID which
/// is already in use by another customer. If this is the first time a user has signed in with the Custom ID and
/// CreateAccount is set to true, a new PlayFab account will be created and linked to the Custom ID. In this case, no email
/// or username will be associated with the PlayFab account. Otherwise, if no PlayFab account is linked to the Custom ID, an
/// error indicating this will be returned, so that the title can guide the user through creation of a PlayFab account.
///
[Serializable]
public class LoginWithCustomIDRequest : PlayFabRequestCommon
{
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// Custom unique identifier for the user, generated by the title.
///
public string CustomId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// Email address and password lengths are provided for information purposes. The server will validate that data passed in
/// conforms to the field definition and report errors appropriately. It is recommended that developers not perform this
/// validation locally, so that future updates do not require client updates.
///
[Serializable]
public class LoginWithEmailAddressRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Email address for the account.
///
public string Email;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Password for the PlayFab account (6-100 characters)
///
public string Password;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
[Serializable]
public class LoginWithFacebookInstantGamesIdRequest : PlayFabRequestCommon
{
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Facebook Instant Games signature for the user.
///
public string FacebookInstantGamesSignature;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// Facebook sign-in is accomplished using the Facebook User Access Token. More information on the Token can be found in the
/// Facebook developer documentation (https://developers.facebook.com/docs/facebook-login/access-tokens/). In Unity, for
/// example, the Token is available as AccessToken in the Facebook SDK ScriptableObject FB. If this is the first time a user
/// has signed in with the Facebook account and CreateAccount is set to true, a new PlayFab account will be created and
/// linked to the provided account's Facebook ID. In this case, no email or username will be associated with the PlayFab
/// account. Otherwise, if no PlayFab account is linked to the Facebook account, an error indicating this will be returned,
/// so that the title can guide the user through creation of a PlayFab account. Note that titles should never re-use the
/// same Facebook applications between PlayFab Title IDs, as Facebook provides unique user IDs per application and doing so
/// can result in issues with the Facebook ID for the user in their PlayFab account information. If you must re-use an
/// application in a new PlayFab Title ID, please be sure to first unlink all accounts from Facebook, or delete all users in
/// the first Title ID. Note: If the user is authenticated with AuthenticationToken, instead of AccessToken, the
/// GetFriendsList API will return an empty list.
///
[Serializable]
public class LoginWithFacebookRequest : PlayFabRequestCommon
{
///
/// Unique identifier from Facebook for the user.
///
public string AccessToken;
///
/// Token used for limited login authentication.
///
public string AuthenticationToken;
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// The Game Center player identifier
/// (https://developer.apple.com/library/ios/documentation/Accounts/Reference/ACAccountClassRef/index.html#//apple_ref/occ/instp/ACAccount/identifier)
/// is a generated string which is stored on the local device. As with device identifiers, care must be taken to never
/// expose a player's Game Center identifier to end users, as that could result in a user's account being compromised. If
/// this is the first time a user has signed in with Game Center and CreateAccount is set to true, a new PlayFab account
/// will be created and linked to the Game Center identifier. In this case, no email or username will be associated with the
/// PlayFab account. Otherwise, if no PlayFab account is linked to the Game Center account, an error indicating this will be
/// returned, so that the title can guide the user through creation of a PlayFab account. If an invalid iOS Game Center
/// player identifier is used, an error indicating this will be returned.
///
[Serializable]
public class LoginWithGameCenterRequest : PlayFabRequestCommon
{
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Unique Game Center player id.
///
public string PlayerId;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// The URL for the public encryption key that will be used to verify the signature.
///
public string PublicKeyUrl;
///
/// A random value used to compute the hash and keep it randomized.
///
public string Salt;
///
/// The verification signature of the authentication payload.
///
public string Signature;
///
/// The integer representation of date and time that the signature was created on. PlayFab will reject authentication
/// signatures not within 10 minutes of the server's current time.
///
public string Timestamp;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// Google sign-in is accomplished by obtaining a Google OAuth 2.0 credential using the Google sign-in for Android APIs on
/// the device and passing it to this API. If this is the first time a user has signed in with the Google account and
/// CreateAccount is set to true, a new PlayFab account will be created and linked to the Google account. Otherwise, if no
/// PlayFab account is linked to the Google account, an error indicating this will be returned, so that the title can guide
/// the user through creation of a PlayFab account. The current (recommended) method for obtaining a Google account
/// credential in an Android application is to call GoogleSignInAccount.getServerAuthCode() and send the auth code as the
/// ServerAuthCode parameter of this API. Before doing this, you must create an OAuth 2.0 web application client ID in the
/// Google API Console and configure its client ID and secret in the PlayFab Game Manager Google Add-on for your title. This
/// method does not require prompting of the user for additional Google account permissions, resulting in a user experience
/// with the least possible friction. For more information about obtaining the server auth code, see
/// https://developers.google.com/identity/sign-in/android/offline-access. The previous (deprecated) method was to obtain an
/// OAuth access token by calling GetAccessToken() on the client and passing it as the AccessToken parameter to this API.
/// for the with the Google OAuth 2.0 Access Token. More information on this change can be found in the Google developer
/// documentation (https://android-developers.googleblog.com/2016/01/play-games-permissions-are-changing-in.html).
///
[Serializable]
public class LoginWithGoogleAccountRequest : PlayFabRequestCommon
{
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// OAuth 2.0 server authentication code obtained on the client by calling the getServerAuthCode()
/// (https://developers.google.com/identity/sign-in/android/offline-access) Google client API.
///
public string ServerAuthCode;
///
/// Optional boolean to opt out of setting the MPA email when creating a Google account, defaults to true.
///
public bool? SetEmail;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// Google Play Games sign-in is accomplished by obtaining a Google OAuth 2.0 credential using the Google Play Games sign-in
/// for Android APIs on the device and passing it to this API. If this is the first time a user has signed in with the
/// Google Play Games account and CreateAccount is set to true, a new PlayFab account will be created and linked to the
/// Google Play Games account. Otherwise, if no PlayFab account is linked to the Google Play Games account, an error
/// indicating this will be returned, so that the title can guide the user through creation of a PlayFab account. The
/// current (recommended) method for obtaining a Google Play Games account credential in an Android application is to call
/// GamesSignInClient.requestServerSideAccess() and send the auth code as the ServerAuthCode parameter of this API. Before
/// doing this, you must create an OAuth 2.0 web application client ID in the Google API Console and configure its client ID
/// and secret in the PlayFab Game Manager Google Add-on for your title. This method does not require prompting of the user
/// for additional Google account permissions, resulting in a user experience with the least possible friction. For more
/// information about obtaining the server auth code, see https://developers.google.com/games/services/android/signin.
///
[Serializable]
public class LoginWithGooglePlayGamesServicesRequest : PlayFabRequestCommon
{
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// OAuth 2.0 server authentication code obtained on the client by calling the requestServerSideAccess()
/// (https://developers.google.com/games/services/android/signin) Google Play Games client API.
///
public string ServerAuthCode;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// On iOS devices, the identifierForVendor
/// (https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIDevice_Class/index.html#//apple_ref/occ/instp/UIDevice/identifierForVendor)
/// must be used as the DeviceId, as the UIDevice uniqueIdentifier has been deprecated as of iOS 5, and use of the
/// advertisingIdentifier for this purpose will result in failure of Apple's certification process. If this is the first
/// time a user has signed in with the iOS device and CreateAccount is set to true, a new PlayFab account will be created
/// and linked to the vendor-specific iOS device ID. In this case, no email or username will be associated with the PlayFab
/// account. Otherwise, if no PlayFab account is linked to the iOS device, an error indicating this will be returned, so
/// that the title can guide the user through creation of a PlayFab account. Please note that while multiple devices of this
/// type can be linked to a single user account, only the one most recently used to login (or most recently linked) will be
/// reflected in the user's account information. We will be updating to show all linked devices in a future release.
///
[Serializable]
public class LoginWithIOSDeviceIDRequest : PlayFabRequestCommon
{
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Vendor-specific iOS identifier for the user's device.
///
public string DeviceId;
///
/// Specific model of the user's device.
///
public string DeviceModel;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Specific Operating System version for the user's device.
///
public string OS;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// More details regarding Kongregate and their game authentication system can be found at
/// http://developers.kongregate.com/docs/virtual-goods/authentication. Developers must provide the Kongregate user ID and
/// auth token that are generated using the Kongregate client library. PlayFab will combine these identifiers with the
/// title's unique Kongregate app ID to log the player into the Kongregate system. If CreateAccount is set to true and there
/// is not already a user matched to this Kongregate ID, then PlayFab will create a new account for this user and link the
/// ID. In this case, no email or username will be associated with the PlayFab account. If there is already a different
/// PlayFab user linked with this account, then an error will be returned.
///
[Serializable]
public class LoginWithKongregateRequest : PlayFabRequestCommon
{
///
/// Token issued by Kongregate's client API for the user.
///
public string AuthTicket;
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Numeric user ID assigned by Kongregate
///
public string KongregateId;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
[Serializable]
public class LoginWithNintendoServiceAccountRequest : PlayFabRequestCommon
{
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// The JSON Web token (JWT) returned by Nintendo after login.
///
public string IdentityToken;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
[Serializable]
public class LoginWithNintendoSwitchDeviceIdRequest : PlayFabRequestCommon
{
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Nintendo Switch unique identifier for the user's device.
///
public string NintendoSwitchDeviceId;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
[Serializable]
public class LoginWithOpenIdConnectRequest : PlayFabRequestCommon
{
///
/// A name that identifies which configured OpenID Connect provider relationship to use. Maximum 100 characters.
///
public string ConnectionId;
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// The JSON Web token (JWT) returned by the identity provider after login. Represented as the id_token field in the
/// identity provider's response.
///
public string IdToken;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// Username and password lengths are provided for information purposes. The server will validate that data passed in
/// conforms to the field definition and report errors appropriately. It is recommended that developers not perform this
/// validation locally, so that future updates to the username or password do not require client updates.
///
[Serializable]
public class LoginWithPlayFabRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Password for the PlayFab account (6-100 characters)
///
public string Password;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
///
/// PlayFab username for the account.
///
public string Username;
}
///
/// If this is the first time a user has signed in with the PlayStation :tm: Network account and CreateAccount is set to
/// true, a new PlayFab account will be created and linked to the PlayStation :tm: Network account. In this case, no email
/// or username will be associated with the PlayFab account. Otherwise, if no PlayFab account is linked to the PlayStation
/// :tm: Network account, an error indicating this will be returned, so that the title can guide the user through creation
/// of a PlayFab account.
///
[Serializable]
public class LoginWithPSNRequest : PlayFabRequestCommon
{
///
/// Auth code provided by the PlayStation :tm: Network OAuth provider.
///
public string AuthCode;
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Id of the PlayStation :tm: Network issuer environment. If null, defaults to production environment.
///
public int? IssuerId;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Redirect URI supplied to PlayStation :tm: Network when requesting an auth code
///
public string RedirectUri;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// Steam sign-in is accomplished with the Steam Session Ticket. More information on the Ticket can be found in the
/// Steamworks SDK, here: https://partner.steamgames.com/documentation/auth. NOTE: For Steam authentication to work, the
/// title must be configured with the Steam Application ID and Web API Key in the PlayFab Game Manager (under Steam in the
/// Add-ons Marketplace). You can obtain a Web API Key from the Permissions page of any Group associated with your App ID in
/// the Steamworks site. If this is the first time a user has signed in with the Steam account and CreateAccount is set to
/// true, a new PlayFab account will be created and linked to the provided account's Steam ID. In this case, no email or
/// username will be associated with the PlayFab account. Otherwise, if no PlayFab account is linked to the Steam account,
/// an error indicating this will be returned, so that the title can guide the user through creation of a PlayFab account.
///
[Serializable]
public class LoginWithSteamRequest : PlayFabRequestCommon
{
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Authentication token for the user, returned as a byte array from Steam, and converted to a string (for example, the byte
/// 0x08 should become "08").
///
public string SteamTicket;
///
/// True if ticket was generated using ISteamUser::GetAuthTicketForWebAPI() using "AzurePlayFab" as the identity string.
/// False if the ticket was generated with ISteamUser::GetAuthSessionTicket().
///
public bool? TicketIsServiceSpecific;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// More details regarding Twitch and their authentication system can be found at
/// https://github.com/justintv/Twitch-API/blob/master/authentication.md. Developers must provide the Twitch access token
/// that is generated using one of the Twitch authentication flows. PlayFab will use the title's unique Twitch Client ID to
/// authenticate the token and log in to the PlayFab system. If CreateAccount is set to true and there is not already a user
/// matched to the Twitch username that generated the token, then PlayFab will create a new account for this user and link
/// the ID. In this case, no email or username will be associated with the PlayFab account. If there is already a different
/// PlayFab user linked with this account, then an error will be returned.
///
[Serializable]
public class LoginWithTwitchRequest : PlayFabRequestCommon
{
///
/// Token issued by Twitch's API for the user.
///
public string AccessToken;
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
///
/// If this is the first time a user has signed in with the Xbox Live account and CreateAccount is set to true, a new
/// PlayFab account will be created and linked to the Xbox Live account. In this case, no email or username will be
/// associated with the PlayFab account. Otherwise, if no PlayFab account is linked to the Xbox Live account, an error
/// indicating this will be returned, so that the title can guide the user through creation of a PlayFab account.
///
[Serializable]
public class LoginWithXboxRequest : PlayFabRequestCommon
{
///
/// Automatically create a PlayFab account if one is not currently linked to this ID.
///
public bool? CreateAccount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
///
/// Token provided by the Xbox Live SDK/XDK method GetTokenAndSignatureAsync("POST", "https://playfabapi.com/", "").
///
public string XboxToken;
}
[Serializable]
public class LogStatement : PlayFabBaseModel
{
///
/// Optional object accompanying the message as contextual information
///
public object Data;
///
/// 'Debug', 'Info', or 'Error'
///
public string Level;
public string Message;
}
[Serializable]
public class MembershipModel : PlayFabBaseModel
{
///
/// Whether this membership is active. That is, whether the MembershipExpiration time has been reached.
///
public bool IsActive;
///
/// The time this membership expires
///
public DateTime MembershipExpiration;
///
/// The id of the membership
///
public string MembershipId;
///
/// Membership expirations can be explicitly overridden (via game manager or the admin api). If this membership has been
/// overridden, this will be the new expiration time.
///
public DateTime? OverrideExpiration;
///
/// The list of subscriptions that this player has for this membership
///
public List Subscriptions;
}
[Serializable]
public class MicrosoftStorePayload : PlayFabBaseModel
{
///
/// Microsoft store ID key. This is optional. Alternatively you can use XboxToken
///
public string CollectionsMsIdKey;
///
/// If collectionsMsIdKey is provided, this will verify the user id in the collectionsMsIdKey is the same.
///
public string UserId;
///
/// Token provided by the Xbox Live SDK/XDK method GetTokenAndSignatureAsync("POST", "https://playfabapi.com/", ""). This is
/// optional. Alternatively can use CollectionsMsIdKey
///
public string XboxToken;
}
[Serializable]
public class ModifyUserVirtualCurrencyResult : PlayFabResultCommon
{
///
/// Balance of the virtual currency after modification.
///
public int Balance;
///
/// Amount added or subtracted from the user's virtual currency. Maximum VC balance is Int32 (2,147,483,647). Any increase
/// over this value will be discarded.
///
public int BalanceChange;
///
/// User currency was subtracted from.
///
public string PlayFabId;
///
/// Name of the virtual currency which was modified.
///
public string VirtualCurrency;
}
///
/// Identifier by either name or ID. Note that a name may change due to renaming, or reused after being deleted. ID is
/// immutable and unique.
///
[Serializable]
public class NameIdentifier : PlayFabBaseModel
{
///
/// Id Identifier, if present
///
public string Id;
///
/// Name Identifier, if present
///
public string Name;
}
[Serializable]
public class NintendoServiceAccountPlayFabIdPair : PlayFabBaseModel
{
///
/// Unique Nintendo Switch Service Account identifier for a user.
///
public string NintendoServiceAccountId;
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the Nintendo Switch Service Account
/// identifier.
///
public string PlayFabId;
}
[Serializable]
public class NintendoSwitchPlayFabIdPair : PlayFabBaseModel
{
///
/// Unique Nintendo Switch Device identifier for a user.
///
public string NintendoSwitchDeviceId;
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the Nintendo Switch Device identifier.
///
public string PlayFabId;
}
[Serializable]
public class OpenTradeRequest : PlayFabRequestCommon
{
///
/// Players who are allowed to accept the trade. If null, the trade may be accepted by any player. If empty, the trade may
/// not be accepted by any player.
///
public List AllowedPlayerIds;
///
/// Player inventory items offered for trade. If not set, the trade is effectively a gift request
///
public List OfferedInventoryInstanceIds;
///
/// Catalog items accepted for the trade. If not set, the trade is effectively a gift.
///
public List RequestedCatalogItemIds;
}
[Serializable]
public class OpenTradeResponse : PlayFabResultCommon
{
///
/// The information about the trade that was just opened.
///
public TradeInfo Trade;
}
///
/// This is the second step in the purchasing process, initiating the purchase transaction with the payment provider (if
/// applicable). For payment provider scenarios, the title should next present the user with the payment provider'sinterface
/// for payment. Once the player has completed the payment with the provider, the title should call ConfirmPurchase
/// tofinalize the process and add the appropriate items to the player inventory.
///
[Serializable]
public class PayForPurchaseRequest : PlayFabRequestCommon
{
///
/// Currency to use to fund the purchase.
///
public string Currency;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Purchase order identifier returned from StartPurchase.
///
public string OrderId;
///
/// Payment provider to use to fund the purchase.
///
public string ProviderName;
///
/// Payment provider transaction identifier. Required for Facebook Payments.
///
public string ProviderTransactionId;
}
///
/// For web-based payment providers, this operation returns the URL to which the user should be directed inorder to approve
/// the purchase. Items added to the user inventory as a result of this operation will be marked as unconfirmed.
///
[Serializable]
public class PayForPurchaseResult : PlayFabResultCommon
{
///
/// Local credit applied to the transaction (provider specific).
///
public uint CreditApplied;
///
/// Purchase order identifier.
///
public string OrderId;
///
/// Provider used for the transaction.
///
public string ProviderData;
///
/// A token generated by the provider to authenticate the request (provider-specific).
///
public string ProviderToken;
///
/// URL to the purchase provider page that details the purchase.
///
public string PurchaseConfirmationPageURL;
///
/// Currency for the transaction, may be a virtual currency or real money.
///
public string PurchaseCurrency;
///
/// Cost of the transaction.
///
public uint PurchasePrice;
///
/// Status of the transaction.
///
public TransactionStatus? Status;
///
/// Virtual currencies granted by the transaction, if any.
///
public Dictionary VCAmount;
///
/// Current virtual currency balances for the user.
///
public Dictionary VirtualCurrency;
}
[Serializable]
public class PaymentOption : PlayFabBaseModel
{
///
/// Specific currency to use to fund the purchase.
///
public string Currency;
///
/// Amount of the specified currency needed for the purchase.
///
public uint Price;
///
/// Name of the purchase provider for this option.
///
public string ProviderName;
///
/// Amount of existing credit the user has with the provider.
///
public uint StoreCredit;
}
[Serializable]
public class PlayerLeaderboardEntry : PlayFabBaseModel
{
///
/// Title-specific display name of the user for this leaderboard entry.
///
public string DisplayName;
///
/// PlayFab unique identifier of the user for this leaderboard entry.
///
public string PlayFabId;
///
/// User's overall position in the leaderboard.
///
public int Position;
///
/// The profile of the user, if requested.
///
public PlayerProfileModel Profile;
///
/// Specific value of the user's statistic.
///
public int StatValue;
}
[Serializable]
public class PlayerProfileModel : PlayFabBaseModel
{
///
/// List of advertising campaigns the player has been attributed to
///
public List AdCampaignAttributions;
///
/// URL of the player's avatar image
///
public string AvatarUrl;
///
/// If the player is currently banned, the UTC Date when the ban expires
///
public DateTime? BannedUntil;
///
/// List of all contact email info associated with the player account
///
public List ContactEmailAddresses;
///
/// Player record created
///
public DateTime? Created;
///
/// Player display name
///
public string DisplayName;
///
/// List of experiment variants for the player. Note that these variants are not guaranteed to be up-to-date when returned
/// during login because the player profile is updated only after login. Instead, use the LoginResult.TreatmentAssignment
/// property during login to get the correct variants and variables.
///
public List ExperimentVariants;
///
/// UTC time when the player most recently logged in to the title
///
public DateTime? LastLogin;
///
/// List of all authentication systems linked to this player account
///
public List LinkedAccounts;
///
/// List of geographic locations from which the player has logged in to the title
///
public List Locations;
///
/// List of memberships for the player, along with whether are expired.
///
public List Memberships;
///
/// Player account origination
///
public LoginIdentityProvider? Origination;
///
/// PlayFab player account unique identifier
///
public string PlayerId;
///
/// Publisher this player belongs to
///
public string PublisherId;
///
/// List of configured end points registered for sending the player push notifications
///
public List PushNotificationRegistrations;
///
/// List of leaderboard statistic values for the player
///
public List Statistics;
///
/// List of player's tags for segmentation
///
public List Tags;
///
/// Title ID this player profile applies to
///
public string TitleId;
///
/// Sum of the player's purchases made with real-money currencies, converted to US dollars equivalent and represented as a
/// whole number of cents (1/100 USD). For example, 999 indicates nine dollars and ninety-nine cents.
///
public uint? TotalValueToDateInUSD;
///
/// List of the player's lifetime purchase totals, summed by real-money currency
///
public List ValuesToDate;
}
[Serializable]
public class PlayerProfileViewConstraints : PlayFabBaseModel
{
///
/// Whether to show player's avatar URL. Defaults to false
///
public bool ShowAvatarUrl;
///
/// Whether to show the banned until time. Defaults to false
///
public bool ShowBannedUntil;
///
/// Whether to show campaign attributions. Defaults to false
///
public bool ShowCampaignAttributions;
///
/// Whether to show contact email addresses. Defaults to false
///
public bool ShowContactEmailAddresses;
///
/// Whether to show the created date. Defaults to false
///
public bool ShowCreated;
///
/// Whether to show the display name. Defaults to false
///
public bool ShowDisplayName;
///
/// Whether to show player's experiment variants. Defaults to false
///
public bool ShowExperimentVariants;
///
/// Whether to show the last login time. Defaults to false
///
public bool ShowLastLogin;
///
/// Whether to show the linked accounts. Defaults to false
///
public bool ShowLinkedAccounts;
///
/// Whether to show player's locations. Defaults to false
///
public bool ShowLocations;
///
/// Whether to show player's membership information. Defaults to false
///
public bool ShowMemberships;
///
/// Whether to show origination. Defaults to false
///
public bool ShowOrigination;
///
/// Whether to show push notification registrations. Defaults to false
///
public bool ShowPushNotificationRegistrations;
///
/// Reserved for future development
///
public bool ShowStatistics;
///
/// Whether to show tags. Defaults to false
///
public bool ShowTags;
///
/// Whether to show the total value to date in usd. Defaults to false
///
public bool ShowTotalValueToDateInUsd;
///
/// Whether to show the values to date. Defaults to false
///
public bool ShowValuesToDate;
}
[Serializable]
public class PlayerStatisticVersion : PlayFabBaseModel
{
///
/// time when the statistic version became active
///
public DateTime ActivationTime;
///
/// time when the statistic version became inactive due to statistic version incrementing
///
public DateTime? DeactivationTime;
///
/// time at which the statistic version was scheduled to become active, based on the configured ResetInterval
///
public DateTime? ScheduledActivationTime;
///
/// time at which the statistic version was scheduled to become inactive, based on the configured ResetInterval
///
public DateTime? ScheduledDeactivationTime;
///
/// name of the statistic when the version became active
///
public string StatisticName;
///
/// version of the statistic
///
public uint Version;
}
[Serializable]
public class PlayStation5Payload : PlayFabBaseModel
{
///
/// An optional list of entitlement ids to query against PlayStation :tm: Network
///
public List Ids;
///
/// Id of the PlayStation :tm: Network service label to consume entitlements from
///
public string ServiceLabel;
}
[Serializable]
public class PSNAccountPlayFabIdPair : PlayFabBaseModel
{
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the PlayStation :tm: Network
/// identifier.
///
public string PlayFabId;
///
/// Unique PlayStation :tm: Network identifier for a user.
///
public string PSNAccountId;
}
[Serializable]
public class PSNOnlinePlayFabIdPair : PlayFabBaseModel
{
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the PlayStation :tm: Network
/// identifier.
///
public string PlayFabId;
///
/// Unique PlayStation :tm: Network identifier for a user.
///
public string PSNOnlineId;
}
///
/// Please note that the processing time for inventory grants and purchases increases fractionally the more items are in the
/// inventory, and the more items are in the grant/purchase operation (with each item in a bundle being a distinct add).
///
[Serializable]
public class PurchaseItemRequest : PlayFabRequestCommon
{
///
/// Catalog version for the items to be purchased (defaults to most recent version.
///
public string CatalogVersion;
///
/// Unique PlayFab assigned ID for a specific character owned by a user
///
public string CharacterId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Unique identifier of the item to purchase.
///
public string ItemId;
///
/// Price the client expects to pay for the item (in case a new catalog or store was uploaded, with new prices).
///
public int Price;
///
/// Store to buy this item through. If not set, prices default to those in the catalog.
///
public string StoreId;
///
/// Virtual currency to use to purchase the item.
///
public string VirtualCurrency;
}
[Serializable]
public class PurchaseItemResult : PlayFabResultCommon
{
///
/// Details for the items purchased.
///
public List Items;
}
[Serializable]
public class PurchaseReceiptFulfillment : PlayFabBaseModel
{
///
/// Items granted to the player in fulfillment of the validated receipt.
///
public List FulfilledItems;
///
/// Source of the payment price information for the recorded purchase transaction. A value of 'Request' indicates that the
/// price specified in the request was used, whereas a value of 'Catalog' indicates that the real-money price of the catalog
/// item matching the product ID in the validated receipt transaction and the currency specified in the request (defaulting
/// to USD) was used.
///
public string RecordedPriceSource;
///
/// Currency used to purchase the items (ISO 4217 currency code).
///
public string RecordedTransactionCurrency;
///
/// Amount of the stated currency paid for the items, in centesimal units
///
public uint? RecordedTransactionTotal;
}
public enum PushNotificationPlatform
{
ApplePushNotificationService,
GoogleCloudMessaging
}
[Serializable]
public class PushNotificationRegistrationModel : PlayFabBaseModel
{
///
/// Notification configured endpoint
///
public string NotificationEndpointARN;
///
/// Push notification platform
///
public PushNotificationPlatform? Platform;
}
///
/// Coupon codes can be created for any item, or set of items, in the catalog for the title. This operation causes the
/// coupon to be consumed, and the specific items to be awarded to the user. Attempting to re-use an already consumed code,
/// or a code which has not yet been created in the service, will result in an error.
///
[Serializable]
public class RedeemCouponRequest : PlayFabRequestCommon
{
///
/// Catalog version of the coupon. If null, uses the default catalog
///
public string CatalogVersion;
///
/// Optional identifier for the Character that should receive the item. If null, item is added to the player
///
public string CharacterId;
///
/// Generated coupon code to redeem.
///
public string CouponCode;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class RedeemCouponResult : PlayFabResultCommon
{
///
/// Items granted to the player as a result of redeeming the coupon.
///
public List GrantedItems;
}
[Serializable]
public class RefreshPSNAuthTokenRequest : PlayFabRequestCommon
{
///
/// Auth code returned by PlayStation :tm: Network OAuth system.
///
public string AuthCode;
///
/// Id of the PlayStation :tm: Network issuer environment. If null, defaults to production environment.
///
public int? IssuerId;
///
/// Redirect URI supplied to PlayStation :tm: Network when requesting an auth code
///
public string RedirectUri;
}
///
/// The steps to configure and send Push Notifications is described in the PlayFab tutorials, here:
/// https://docs.microsoft.com/gaming/playfab/features/engagement/push-notifications/quickstart
///
[Serializable]
public class RegisterForIOSPushNotificationRequest : PlayFabRequestCommon
{
///
/// Message to display when confirming push notification.
///
public string ConfirmationMessage;
///
/// Unique token generated by the Apple Push Notification service when the title registered to receive push notifications.
///
public string DeviceToken;
///
/// If true, send a test push message immediately after sucessful registration. Defaults to false.
///
public bool? SendPushNotificationConfirmation;
}
[Serializable]
public class RegisterForIOSPushNotificationResult : PlayFabResultCommon
{
}
[Serializable]
public class RegisterPlayFabUserRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// An optional parameter for setting the display name for this title (3-25 characters).
///
public string DisplayName;
///
/// User email address attached to their account
///
public string Email;
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Flags for which pieces of info to return for the user.
///
public GetPlayerCombinedInfoRequestParams InfoRequestParameters;
///
/// Password for the PlayFab account (6-100 characters)
///
public string Password;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
///
/// An optional parameter that specifies whether both the username and email parameters are required. If true, both
/// parameters are required; if false, the user must supply either the username or email parameter. The default value is
/// true.
///
public bool? RequireBothUsernameAndEmail;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
///
/// PlayFab username for the account (3-20 characters)
///
public string Username;
}
///
/// Each account must have a unique email address in the PlayFab service. Once created, the account may be associated with
/// additional accounts (Steam, Facebook, Game Center, etc.), allowing for added social network lists and achievements
/// systems.
///
[Serializable]
public class RegisterPlayFabUserResult : PlayFabLoginResultCommon
{
///
/// If LoginTitlePlayerAccountEntity flag is set on the login request the title_player_account will also be logged in and
/// returned.
///
public EntityTokenResponse EntityToken;
///
/// PlayFab unique identifier for this newly created account.
///
public string PlayFabId;
///
/// Unique token identifying the user and game at the server level, for the current session.
///
public string SessionTicket;
///
/// Settings specific to this user.
///
public UserSettings SettingsForUser;
///
/// PlayFab unique user name.
///
public string Username;
}
///
/// This API removes an existing contact email from the player's profile.
///
[Serializable]
public class RemoveContactEmailRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class RemoveContactEmailResult : PlayFabResultCommon
{
}
[Serializable]
public class RemoveFriendRequest : PlayFabRequestCommon
{
///
/// PlayFab identifier of the friend account which is to be removed.
///
public string FriendPlayFabId;
}
[Serializable]
public class RemoveFriendResult : PlayFabResultCommon
{
}
[Serializable]
public class RemoveGenericIDRequest : PlayFabRequestCommon
{
///
/// Generic service identifier to be removed from the player.
///
public GenericServiceId GenericId;
}
[Serializable]
public class RemoveGenericIDResult : PlayFabResultCommon
{
}
[Serializable]
public class RemoveSharedGroupMembersRequest : PlayFabRequestCommon
{
///
/// An array of unique PlayFab assigned ID of the user on whom the operation will be performed.
///
public List PlayFabIds;
///
/// Unique identifier for the shared group.
///
public string SharedGroupId;
}
[Serializable]
public class RemoveSharedGroupMembersResult : PlayFabResultCommon
{
}
///
/// Report ad activity
///
[Serializable]
public class ReportAdActivityRequest : PlayFabRequestCommon
{
///
/// Type of activity, may be Opened, Closed, Start or End
///
public AdActivity Activity;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Unique ID of the placement to report for
///
public string PlacementId;
///
/// Unique ID of the reward the player was offered
///
public string RewardId;
}
///
/// Report ad activity response has no body
///
[Serializable]
public class ReportAdActivityResult : PlayFabResultCommon
{
}
[Serializable]
public class ReportPlayerClientRequest : PlayFabRequestCommon
{
///
/// Optional additional comment by reporting player.
///
public string Comment;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Unique PlayFab identifier of the reported player.
///
public string ReporteeId;
}
///
/// Players are currently limited to five reports per day. Attempts by a single user account to submit reports beyond five
/// will result in Updated being returned as false.
///
[Serializable]
public class ReportPlayerClientResult : PlayFabResultCommon
{
///
/// The number of remaining reports which may be filed today.
///
public int SubmissionsRemaining;
}
///
/// The title should obtain a refresh receipt via restoreCompletedTransactions in the SKPaymentQueue of the Apple StoreKit
/// and pass that in to this call. The resultant receipt contains new receipt instances for all non-consumable goods
/// previously purchased by the user. This API call iterates through every purchase in the receipt and restores the items if
/// they still exist in the catalog and can be validated.
///
[Serializable]
public class RestoreIOSPurchasesRequest : PlayFabRequestCommon
{
///
/// Catalog version of the restored items. If null, defaults to primary catalog.
///
public string CatalogVersion;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Base64 encoded receipt data, passed back by the App Store as a result of a successful purchase.
///
public string ReceiptData;
}
///
/// Once verified, the valid items will be restored into the user's inventory. This result should be used for immediate
/// updates to the local client game state as opposed to the GetUserInventory API which can have an up to half second delay.
///
[Serializable]
public class RestoreIOSPurchasesResult : PlayFabResultCommon
{
///
/// Fulfilled inventory items and recorded purchases in fulfillment of the validated receipt transactions.
///
public List Fulfillments;
}
///
/// Details on which placement and reward to perform a grant on
///
[Serializable]
public class RewardAdActivityRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Placement unique ID
///
public string PlacementId;
///
/// Reward unique ID
///
public string RewardId;
}
///
/// Result for rewarding an ad activity
///
[Serializable]
public class RewardAdActivityResult : PlayFabResultCommon
{
///
/// PlayStream Event ID that was generated by this reward (all subsequent events are associated with this event identifier)
///
public string AdActivityEventId;
///
/// Debug results from the grants
///
public List DebugResults;
///
/// Id of the placement the reward was for
///
public string PlacementId;
///
/// Name of the placement the reward was for
///
public string PlacementName;
///
/// If placement has viewing limits indicates how many views are left
///
public int? PlacementViewsRemaining;
///
/// If placement has viewing limits indicates when they will next reset
///
public double? PlacementViewsResetMinutes;
///
/// Reward results
///
public AdRewardResults RewardResults;
}
[Serializable]
public class ScriptExecutionError : PlayFabBaseModel
{
///
/// Error code, such as CloudScriptNotFound, JavascriptException, CloudScriptFunctionArgumentSizeExceeded,
/// CloudScriptAPIRequestCountExceeded, CloudScriptAPIRequestError, or CloudScriptHTTPRequestError
///
public string Error;
///
/// Details about the error
///
public string Message;
///
/// Point during the execution of the script at which the error occurred, if any
///
public string StackTrace;
}
///
/// If the account in question is a "temporary" account (for example, one that was created via a call to
/// LoginFromIOSDeviceID), thisfunction will have no effect. Only PlayFab accounts which have valid email addresses will be
/// able to receive a password reset email using this API.
///
[Serializable]
public class SendAccountRecoveryEmailRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// User email address attached to their account
///
public string Email;
///
/// The email template id of the account recovery email template to send.
///
public string EmailTemplateId;
///
/// Unique identifier for the title, found in the Settings > Game Properties section of the PlayFab developer site when a
/// title has been selected.
///
public string TitleId;
}
[Serializable]
public class SendAccountRecoveryEmailResult : PlayFabResultCommon
{
}
///
/// This operation is not additive. It will completely replace the tag list for the specified user. Please note that only
/// users in the PlayFab friends list can be assigned tags. Attempting to set a tag on a friend only included in the friends
/// list from a social site integration (such as Facebook or Steam) will return the AccountNotFound error.
///
[Serializable]
public class SetFriendTagsRequest : PlayFabRequestCommon
{
///
/// PlayFab identifier of the friend account to which the tag(s) should be applied.
///
public string FriendPlayFabId;
///
/// Array of tags to set on the friend account.
///
public List Tags;
}
[Serializable]
public class SetFriendTagsResult : PlayFabResultCommon
{
}
///
/// APIs that require signatures require that the player have a configured Player Secret Key that is used to sign all
/// requests. Players that don't have a secret will be blocked from making API calls until it is configured. To create a
/// signature header add a SHA256 hashed string containing UTF8 encoded JSON body as it will be sent to the server, the
/// current time in UTC formatted to ISO 8601, and the players secret formatted as 'body.date.secret'. Place the resulting
/// hash into the header X-PlayFab-Signature, along with a header X-PlayFab-Timestamp of the same UTC timestamp used in the
/// signature.
///
[Serializable]
public class SetPlayerSecretRequest : PlayFabRequestCommon
{
///
/// Base64 encoded body that is encrypted with the Title's public RSA key (Enterprise Only).
///
public string EncryptedRequest;
///
/// Player secret that is used to verify API request signatures (Enterprise Only).
///
public string PlayerSecret;
}
[Serializable]
public class SetPlayerSecretResult : PlayFabResultCommon
{
}
[Serializable]
public class SharedGroupDataRecord : PlayFabBaseModel
{
///
/// Timestamp for when this data was last updated.
///
public DateTime LastUpdated;
///
/// Unique PlayFab identifier of the user to last update this value.
///
public string LastUpdatedBy;
///
/// Indicates whether this data can be read by all users (public) or only members of the group (private).
///
public UserDataPermission? Permission;
///
/// Data stored for the specified group data key.
///
public string Value;
}
public enum SourceType
{
Admin,
BackEnd,
GameClient,
GameServer,
Partner,
Custom,
API
}
///
/// This is the first step in the purchasing process. For security purposes, once the order (or "cart") has been created,
/// additional inventory objects may no longer be added. In addition, inventory objects will be locked to the current
/// prices, regardless of any subsequent changes at the catalog level which may occur during the next two steps.
///
[Serializable]
public class StartPurchaseRequest : PlayFabRequestCommon
{
///
/// Catalog version for the items to be purchased. Defaults to most recent catalog.
///
public string CatalogVersion;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Array of items to purchase.
///
public List Items;
///
/// Store through which to purchase items. If not set, prices will be pulled from the catalog itself.
///
public string StoreId;
}
[Serializable]
public class StartPurchaseResult : PlayFabResultCommon
{
///
/// Cart items to be purchased.
///
public List Contents;
///
/// Purchase order identifier.
///
public string OrderId;
///
/// Available methods by which the user can pay.
///
public List PaymentOptions;
///
/// Current virtual currency totals for the user.
///
public Dictionary VirtualCurrencyBalances;
}
[Serializable]
public class StatisticModel : PlayFabBaseModel
{
///
/// Statistic name
///
public string Name;
///
/// Statistic value
///
public int Value;
///
/// Statistic version (0 if not a versioned statistic)
///
public int Version;
}
[Serializable]
public class StatisticNameVersion : PlayFabBaseModel
{
///
/// unique name of the statistic
///
public string StatisticName;
///
/// the version of the statistic to be returned
///
public uint Version;
}
[Serializable]
public class StatisticUpdate : PlayFabBaseModel
{
///
/// unique name of the statistic
///
public string StatisticName;
///
/// statistic value for the player
///
public int Value;
///
/// for updates to an existing statistic value for a player, the version of the statistic when it was loaded. Null when
/// setting the statistic value for the first time.
///
public uint? Version;
}
[Serializable]
public class StatisticValue : PlayFabBaseModel
{
///
/// unique name of the statistic
///
public string StatisticName;
///
/// statistic value for the player
///
public int Value;
///
/// for updates to an existing statistic value for a player, the version of the statistic when it was loaded
///
public uint Version;
}
[Serializable]
public class SteamPlayFabIdPair : PlayFabBaseModel
{
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the Steam identifier.
///
public string PlayFabId;
///
/// Unique Steam identifier for a user.
///
public string SteamStringId;
}
///
/// A store entry that list a catalog item at a particular price
///
[Serializable]
public class StoreItem : PlayFabBaseModel
{
///
/// Store specific custom data. The data only exists as part of this store; it is not transferred to item instances
///
public object CustomData;
///
/// Intended display position for this item. Note that 0 is the first position
///
public uint? DisplayPosition;
///
/// Unique identifier of the item as it exists in the catalog - note that this must exactly match the ItemId from the
/// catalog
///
public string ItemId;
///
/// Override prices for this item for specific currencies
///
public Dictionary RealCurrencyPrices;
///
/// Override prices for this item in virtual currencies and "RM" (the base Real Money purchase price, in USD pennies)
///
public Dictionary VirtualCurrencyPrices;
}
///
/// Marketing data about a specific store
///
[Serializable]
public class StoreMarketingModel : PlayFabBaseModel
{
///
/// Tagline for a store.
///
public string Description;
///
/// Display name of a store as it will appear to users.
///
public string DisplayName;
///
/// Custom data about a store.
///
public object Metadata;
}
[Serializable]
public class SubscriptionModel : PlayFabBaseModel
{
///
/// When this subscription expires.
///
public DateTime Expiration;
///
/// The time the subscription was orignially purchased
///
public DateTime InitialSubscriptionTime;
///
/// Whether this subscription is currently active. That is, if Expiration > now.
///
public bool IsActive;
///
/// The status of this subscription, according to the subscription provider.
///
public SubscriptionProviderStatus? Status;
///
/// The id for this subscription
///
public string SubscriptionId;
///
/// The item id for this subscription from the primary catalog
///
public string SubscriptionItemId;
///
/// The provider for this subscription. Apple or Google Play are supported today.
///
public string SubscriptionProvider;
}
public enum SubscriptionProviderStatus
{
NoError,
Cancelled,
UnknownError,
BillingError,
ProductUnavailable,
CustomerDidNotAcceptPriceChange,
FreeTrial,
PaymentPending
}
///
/// This API must be enabled for use as an option in the game manager website. It is disabled by default.
///
[Serializable]
public class SubtractUserVirtualCurrencyRequest : PlayFabRequestCommon
{
///
/// Amount to be subtracted from the user balance of the specified virtual currency.
///
public int Amount;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Name of the virtual currency which is to be decremented.
///
public string VirtualCurrency;
}
[Serializable]
public class TagModel : PlayFabBaseModel
{
///
/// Full value of the tag, including namespace
///
public string TagValue;
}
public enum TitleActivationStatus
{
None,
ActivatedTitleKey,
PendingSteam,
ActivatedSteam,
RevokedSteam
}
[Serializable]
public class TitleNewsItem : PlayFabBaseModel
{
///
/// News item text.
///
public string Body;
///
/// Unique identifier of news item.
///
public string NewsId;
///
/// Date and time when the news item was posted.
///
public DateTime Timestamp;
///
/// Title of the news item.
///
public string Title;
}
[Serializable]
public class TradeInfo : PlayFabBaseModel
{
///
/// Item instances from the accepting player that are used to fulfill the trade. If null, no one has accepted the trade.
///
public List AcceptedInventoryInstanceIds;
///
/// The PlayFab ID of the player who accepted the trade. If null, no one has accepted the trade.
///
public string AcceptedPlayerId;
///
/// An optional list of players allowed to complete this trade. If null, anybody can complete the trade.
///
public List AllowedPlayerIds;
///
/// If set, The UTC time when this trade was canceled.
///
public DateTime? CancelledAt;
///
/// If set, The UTC time when this trade was fulfilled.
///
public DateTime? FilledAt;
///
/// If set, The UTC time when this trade was made invalid.
///
public DateTime? InvalidatedAt;
///
/// The catalogItem Ids of the item instances being offered.
///
public List OfferedCatalogItemIds;
///
/// The itemInstance Ids that are being offered.
///
public List OfferedInventoryInstanceIds;
///
/// The PlayFabId for the offering player.
///
public string OfferingPlayerId;
///
/// The UTC time when this trade was created.
///
public DateTime? OpenedAt;
///
/// The catalogItem Ids requested in exchange.
///
public List RequestedCatalogItemIds;
///
/// Describes the current state of this trade.
///
public TradeStatus? Status;
///
/// The identifier for this trade.
///
public string TradeId;
}
public enum TradeStatus
{
Invalid,
Opening,
Open,
Accepting,
Accepted,
Filled,
Cancelled
}
public enum TransactionStatus
{
CreateCart,
Init,
Approved,
Succeeded,
FailedByProvider,
DisputePending,
RefundPending,
Refunded,
RefundFailed,
ChargedBack,
FailedByUber,
FailedByPlayFab,
Revoked,
TradePending,
Traded,
Upgraded,
StackPending,
Stacked,
Other,
Failed
}
[Serializable]
public class TreatmentAssignment : PlayFabBaseModel
{
///
/// List of the experiment variables.
///
public List Variables;
///
/// List of the experiment variants.
///
public List Variants;
}
[Serializable]
public class TwitchPlayFabIdPair : PlayFabBaseModel
{
///
/// Unique PlayFab identifier for a user, or null if no PlayFab account is linked to the Twitch identifier.
///
public string PlayFabId;
///
/// Unique Twitch identifier for a user.
///
public string TwitchId;
}
[Serializable]
public class UnlinkAndroidDeviceIDRequest : PlayFabRequestCommon
{
///
/// Android device identifier for the user's device. If not specified, the most recently signed in Android Device ID will be
/// used.
///
public string AndroidDeviceId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkAndroidDeviceIDResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkAppleRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkCustomIDRequest : PlayFabRequestCommon
{
///
/// Custom unique identifier for the user, generated by the title. If not specified, the most recently signed in Custom ID
/// will be used.
///
public string CustomId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkCustomIDResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkFacebookAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkFacebookAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkFacebookInstantGamesIdRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Facebook Instant Games identifier for the user. If not specified, the most recently signed in ID will be used.
///
public string FacebookInstantGamesId;
}
[Serializable]
public class UnlinkFacebookInstantGamesIdResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkGameCenterAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkGameCenterAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkGoogleAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkGoogleAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkGooglePlayGamesServicesAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkGooglePlayGamesServicesAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkIOSDeviceIDRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Vendor-specific iOS identifier for the user's device. If not specified, the most recently signed in iOS Device ID will
/// be used.
///
public string DeviceId;
}
[Serializable]
public class UnlinkIOSDeviceIDResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkKongregateAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkKongregateAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkNintendoServiceAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkNintendoSwitchDeviceIdRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Nintendo Switch Device identifier for the user. If not specified, the most recently signed in device ID will be used.
///
public string NintendoSwitchDeviceId;
}
[Serializable]
public class UnlinkNintendoSwitchDeviceIdResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkOpenIdConnectRequest : PlayFabRequestCommon
{
///
/// A name that identifies which configured OpenID Connect provider relationship to use. Maximum 100 characters.
///
public string ConnectionId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkPSNAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkPSNAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkSteamAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkSteamAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkTwitchAccountRequest : PlayFabRequestCommon
{
///
/// Valid token issued by Twitch. Used to specify which twitch account to unlink from the profile. By default it uses the
/// one that is present on the profile.
///
public string AccessToken;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkTwitchAccountResult : PlayFabResultCommon
{
}
[Serializable]
public class UnlinkXboxAccountRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UnlinkXboxAccountResult : PlayFabResultCommon
{
}
///
/// Specify the container and optionally the catalogVersion for the container to open
///
[Serializable]
public class UnlockContainerInstanceRequest : PlayFabRequestCommon
{
///
/// Specifies the catalog version that should be used to determine container contents. If unspecified, uses catalog
/// associated with the item instance.
///
public string CatalogVersion;
///
/// Unique PlayFab assigned ID for a specific character owned by a user
///
public string CharacterId;
///
/// ItemInstanceId of the container to unlock.
///
public string ContainerItemInstanceId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// ItemInstanceId of the key that will be consumed by unlocking this container. If the container requires a key, this
/// parameter is required.
///
public string KeyItemInstanceId;
}
///
/// Specify the type of container to open and optionally the catalogVersion for the container to open
///
[Serializable]
public class UnlockContainerItemRequest : PlayFabRequestCommon
{
///
/// Specifies the catalog version that should be used to determine container contents. If unspecified, uses default/primary
/// catalog.
///
public string CatalogVersion;
///
/// Unique PlayFab assigned ID for a specific character owned by a user
///
public string CharacterId;
///
/// Catalog ItemId of the container type to unlock.
///
public string ContainerItemId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
///
/// The items and vc found within the container. These will be added and stacked in the appropriate inventory.
///
[Serializable]
public class UnlockContainerItemResult : PlayFabResultCommon
{
///
/// Items granted to the player as a result of unlocking the container.
///
public List GrantedItems;
///
/// Unique instance identifier of the container unlocked.
///
public string UnlockedItemInstanceId;
///
/// Unique instance identifier of the key used to unlock the container, if applicable.
///
public string UnlockedWithItemInstanceId;
///
/// Virtual currency granted to the player as a result of unlocking the container.
///
public Dictionary VirtualCurrency;
}
[Serializable]
public class UpdateAvatarUrlRequest : PlayFabRequestCommon
{
///
/// URL of the avatar image. If empty, it removes the existing avatar URL.
///
public string ImageUrl;
}
///
/// This function performs an additive update of the arbitrary strings containing the custom data for the character. In
/// updating the custom data object, keys which already exist in the object will have their values overwritten, while keys
/// with null values will be removed. New keys will be added, with the given values. No other key-value pairs will be
/// changed apart from those specified in the call.
///
[Serializable]
public class UpdateCharacterDataRequest : PlayFabRequestCommon
{
///
/// Unique PlayFab assigned ID for a specific character owned by a user
///
public string CharacterId;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Key-value pairs to be written to the custom data. Note that keys are trimmed of whitespace, are limited in size, and may
/// not begin with a '!' character or be null.
///
public Dictionary Data;
///
/// Optional list of Data-keys to remove from UserData. Some SDKs cannot insert null-values into Data due to language
/// constraints. Use this to delete the keys directly.
///
public List KeysToRemove;
///
/// Permission to be applied to all user data keys written in this request. Defaults to "private" if not set.
///
public UserDataPermission? Permission;
}
[Serializable]
public class UpdateCharacterDataResult : PlayFabResultCommon
{
///
/// Indicates the current version of the data that has been set. This is incremented with every set call for that type of
/// data (read-only, internal, etc). This version can be provided in Get calls to find updated data.
///
public uint DataVersion;
}
///
/// Enable this option with the 'Allow Client to Post Player Statistics' option in PlayFab GameManager for your title.
/// However, this is not best practice, as this data will no longer be safely controlled by the server. This operation is
/// additive. Character Statistics not currently defined will be added, while those already defined will be updated with the
/// given values. All other user statistics will remain unchanged. Character statistics are used by the
/// character-leaderboard apis, and accessible for custom game-logic.
///
[Serializable]
public class UpdateCharacterStatisticsRequest : PlayFabRequestCommon
{
///
/// Unique PlayFab assigned ID for a specific character owned by a user
///
public string CharacterId;
///
/// Statistics to be updated with the provided values, in the Key(string), Value(int) pattern.
///
public Dictionary CharacterStatistics;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
}
[Serializable]
public class UpdateCharacterStatisticsResult : PlayFabResultCommon
{
}
///
/// Enable this option with the 'Allow Client to Post Player Statistics' option in PlayFab GameManager for your title.
/// However, this is not best practice, as this data will no longer be safely controlled by the server. This operation is
/// additive. Statistics not currently defined will be added, while those already defined will be updated with the given
/// values. All other user statistics will remain unchanged. Note that if the statistic is intended to have a reset period,
/// the UpdatePlayerStatisticDefinition API call can be used to define that reset period. Once a statistic has been
/// versioned (reset), the now-previous version can still be written to for up a short, pre-defined period (currently 10
/// seconds), using the Version parameter in this call.
///
[Serializable]
public class UpdatePlayerStatisticsRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Statistics to be updated with the provided values
///
public List Statistics;
}
[Serializable]
public class UpdatePlayerStatisticsResult : PlayFabResultCommon
{
}
///
/// Note that in the case of multiple calls to write to the same shared group data keys, the last write received by the
/// PlayFab service will determine the value available to subsequent read operations. For scenarios requiring coordination
/// of data updates, it is recommended that titles make use of user data with read permission set to public, or a
/// combination of user data and shared group data.
///
[Serializable]
public class UpdateSharedGroupDataRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Key-value pairs to be written to the custom data. Note that keys are trimmed of whitespace, are limited in size, and may
/// not begin with a '!' character or be null.
///
public Dictionary Data;
///
/// Optional list of Data-keys to remove from UserData. Some SDKs cannot insert null-values into Data due to language
/// constraints. Use this to delete the keys directly.
///
public List KeysToRemove;
///
/// Permission to be applied to all user data keys in this request.
///
public UserDataPermission? Permission;
///
/// Unique identifier for the shared group.
///
public string SharedGroupId;
}
[Serializable]
public class UpdateSharedGroupDataResult : PlayFabResultCommon
{
}
///
/// This function performs an additive update of the arbitrary strings containing the custom data for the user. In updating
/// the custom data object, keys which already exist in the object will have their values overwritten, while keys with null
/// values will be removed. New keys will be added, with the given values. No other key-value pairs will be changed apart
/// from those specified in the call.
///
[Serializable]
public class UpdateUserDataRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// Key-value pairs to be written to the custom data. Note that keys are trimmed of whitespace, are limited in size, and may
/// not begin with a '!' character or be null.
///
public Dictionary Data;
///
/// Optional list of Data-keys to remove from UserData. Some SDKs cannot insert null-values into Data due to language
/// constraints. Use this to delete the keys directly.
///
public List KeysToRemove;
///
/// Permission to be applied to all user data keys written in this request. Defaults to "private" if not set. This is used
/// for requests by one player for information about another player; those requests will only return Public keys.
///
public UserDataPermission? Permission;
}
[Serializable]
public class UpdateUserDataResult : PlayFabResultCommon
{
///
/// Indicates the current version of the data that has been set. This is incremented with every set call for that type of
/// data (read-only, internal, etc). This version can be provided in Get calls to find updated data.
///
public uint DataVersion;
}
///
/// In addition to the PlayFab username, titles can make use of a DisplayName which is also a unique identifier, but
/// specific to the title. This allows for unique names which more closely match the theme or genre of a title, for example.
///
[Serializable]
public class UpdateUserTitleDisplayNameRequest : PlayFabRequestCommon
{
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///
/// New title display name for the user - must be between 3 and 25 characters.
///
public string DisplayName;
}
[Serializable]
public class UpdateUserTitleDisplayNameResult : PlayFabResultCommon
{
///
/// Current title display name for the user (this will be the original display name if the rename attempt failed).
///
public string DisplayName;
}
[Serializable]
public class UserAccountInfo : PlayFabBaseModel
{
///
/// User Android device information, if an Android device has been linked
///
public UserAndroidDeviceInfo AndroidDeviceInfo;
///
/// Sign in with Apple account information, if an Apple account has been linked
///
public UserAppleIdInfo AppleAccountInfo;
///
/// Timestamp indicating when the user account was created
///
public DateTime Created;
///
/// Custom ID information, if a custom ID has been assigned
///
public UserCustomIdInfo CustomIdInfo;
///
/// User Facebook information, if a Facebook account has been linked
///
public UserFacebookInfo FacebookInfo;
///
/// Facebook Instant Games account information, if a Facebook Instant Games account has been linked
///
public UserFacebookInstantGamesIdInfo FacebookInstantGamesIdInfo;
///
/// User Gamecenter information, if a Gamecenter account has been linked
///
public UserGameCenterInfo GameCenterInfo;
///
/// User Google account information, if a Google account has been linked
///
public UserGoogleInfo GoogleInfo;
///
/// User Google Play Games account information, if a Google Play Games account has been linked
///
public UserGooglePlayGamesInfo GooglePlayGamesInfo;
///
/// User iOS device information, if an iOS device has been linked
///
public UserIosDeviceInfo IosDeviceInfo;
///
/// User Kongregate account information, if a Kongregate account has been linked
///
public UserKongregateInfo KongregateInfo;
///
/// Nintendo Switch account information, if a Nintendo Switch account has been linked
///
public UserNintendoSwitchAccountIdInfo NintendoSwitchAccountInfo;
///
/// Nintendo Switch device information, if a Nintendo Switch device has been linked
///
public UserNintendoSwitchDeviceIdInfo NintendoSwitchDeviceIdInfo;
///
/// OpenID Connect information, if any OpenID Connect accounts have been linked
///
public List OpenIdInfo;
///
/// Unique identifier for the user account
///
public string PlayFabId;
///
/// Personal information for the user which is considered more sensitive
///
public UserPrivateAccountInfo PrivateInfo;
///
/// User PlayStation :tm: Network account information, if a PlayStation :tm: Network account has been linked
///
public UserPsnInfo PsnInfo;
///
/// Server Custom ID information, if a server custom ID has been assigned
///
public UserServerCustomIdInfo ServerCustomIdInfo;
///
/// User Steam information, if a Steam account has been linked
///
public UserSteamInfo SteamInfo;
///
/// Title-specific information for the user account
///
public UserTitleInfo TitleInfo;
///
/// User Twitch account information, if a Twitch account has been linked
///
public UserTwitchInfo TwitchInfo;
///
/// User account name in the PlayFab service
///
public string Username;
///
/// User XBox account information, if a XBox account has been linked
///
public UserXboxInfo XboxInfo;
}
[Serializable]
public class UserAndroidDeviceInfo : PlayFabBaseModel
{
///
/// Android device ID
///
public string AndroidDeviceId;
}
[Serializable]
public class UserAppleIdInfo : PlayFabBaseModel
{
///
/// Apple subject ID
///
public string AppleSubjectId;
}
[Serializable]
public class UserCustomIdInfo : PlayFabBaseModel
{
///
/// Custom ID
///
public string CustomId;
}
///
/// Indicates whether a given data key is private (readable only by the player) or public (readable by all players). When a
/// player makes a GetUserData request about another player, only keys marked Public will be returned.
///
public enum UserDataPermission
{
Private,
Public
}
[Serializable]
public class UserDataRecord : PlayFabBaseModel
{
///
/// Timestamp for when this data was last updated.
///
public DateTime LastUpdated;
///
/// Indicates whether this data can be read by all users (public) or only the user (private). This is used for GetUserData
/// requests being made by one player about another player.
///
public UserDataPermission? Permission;
///
/// Data stored for the specified user data key.
///
public string Value;
}
[Serializable]
public class UserFacebookInfo : PlayFabBaseModel
{
///
/// Facebook identifier
///
public string FacebookId;
///
/// Facebook full name
///
public string FullName;
}
[Serializable]
public class UserFacebookInstantGamesIdInfo : PlayFabBaseModel
{
///
/// Facebook Instant Games ID
///
public string FacebookInstantGamesId;
}
[Serializable]
public class UserGameCenterInfo : PlayFabBaseModel
{
///
/// Gamecenter identifier
///
public string GameCenterId;
}
[Serializable]
public class UserGoogleInfo : PlayFabBaseModel
{
///
/// Email address of the Google account
///
public string GoogleEmail;
///
/// Gender information of the Google account
///
public string GoogleGender;
///
/// Google ID
///
public string GoogleId;
///
/// Locale of the Google account
///
public string GoogleLocale;
///
/// Name of the Google account user
///
public string GoogleName;
}
[Serializable]
public class UserGooglePlayGamesInfo : PlayFabBaseModel
{
///
/// Avatar image url of the Google Play Games player
///
public string GooglePlayGamesPlayerAvatarImageUrl;
///
/// Display name of the Google Play Games player
///
public string GooglePlayGamesPlayerDisplayName;
///
/// Google Play Games player ID
///
public string GooglePlayGamesPlayerId;
}
[Serializable]
public class UserIosDeviceInfo : PlayFabBaseModel
{
///
/// iOS device ID
///
public string IosDeviceId;
}
[Serializable]
public class UserKongregateInfo : PlayFabBaseModel
{
///
/// Kongregate ID
///
public string KongregateId;
///
/// Kongregate Username
///
public string KongregateName;
}
[Serializable]
public class UserNintendoSwitchAccountIdInfo : PlayFabBaseModel
{
///
/// Nintendo Switch account subject ID
///
public string NintendoSwitchAccountSubjectId;
}
[Serializable]
public class UserNintendoSwitchDeviceIdInfo : PlayFabBaseModel
{
///
/// Nintendo Switch Device ID
///
public string NintendoSwitchDeviceId;
}
[Serializable]
public class UserOpenIdInfo : PlayFabBaseModel
{
///
/// OpenID Connection ID
///
public string ConnectionId;
///
/// OpenID Issuer
///
public string Issuer;
///
/// OpenID Subject
///
public string Subject;
}
public enum UserOrigination
{
Organic,
Steam,
Google,
Amazon,
Facebook,
Kongregate,
GamersFirst,
Unknown,
IOS,
LoadTest,
Android,
PSN,
GameCenter,
CustomId,
XboxLive,
Parse,
Twitch,
ServerCustomId,
NintendoSwitchDeviceId,
FacebookInstantGamesId,
OpenIdConnect,
Apple,
NintendoSwitchAccount,
GooglePlayGames,
XboxMobileStore,
King
}
[Serializable]
public class UserPrivateAccountInfo : PlayFabBaseModel
{
///
/// user email address
///
public string Email;
}
[Serializable]
public class UserPsnInfo : PlayFabBaseModel
{
///
/// PlayStation :tm: Network account ID
///
public string PsnAccountId;
///
/// PlayStation :tm: Network online ID
///
public string PsnOnlineId;
}
[Serializable]
public class UserServerCustomIdInfo : PlayFabBaseModel
{
///
/// Custom ID
///
public string CustomId;
}
[Serializable]
public class UserSettings : PlayFabBaseModel
{
///
/// Boolean for whether this player is eligible for gathering device info.
///
public bool GatherDeviceInfo;
///
/// Boolean for whether this player should report OnFocus play-time tracking.
///
public bool GatherFocusInfo;
///
/// Boolean for whether this player is eligible for ad tracking.
///
public bool NeedsAttribution;
}
[Serializable]
public class UserSteamInfo : PlayFabBaseModel
{
///
/// what stage of game ownership the user is listed as being in, from Steam
///
public TitleActivationStatus? SteamActivationStatus;
///
/// the country in which the player resides, from Steam data
///
public string SteamCountry;
///
/// currency type set in the user Steam account
///
public Currency? SteamCurrency;
///
/// Steam identifier
///
public string SteamId;
///
/// Steam display name
///
public string SteamName;
}
[Serializable]
public class UserTitleInfo : PlayFabBaseModel
{
///
/// URL to the player's avatar.
///
public string AvatarUrl;
///
/// timestamp indicating when the user was first associated with this game (this can differ significantly from when the user
/// first registered with PlayFab)
///
public DateTime Created;
///
/// name of the user, as it is displayed in-game
///
public string DisplayName;
///
/// timestamp indicating when the user first signed into this game (this can differ from the Created timestamp, as other
/// events, such as issuing a beta key to the user, can associate the title to the user)
///
public DateTime? FirstLogin;
///
/// boolean indicating whether or not the user is currently banned for a title
///
public bool? isBanned;
///
/// timestamp for the last user login for this title
///
public DateTime? LastLogin;
///
/// source by which the user first joined the game, if known
///
public UserOrigination? Origination;
///
/// Title player account entity for this user
///
public EntityKey TitlePlayerAccount;
}
[Serializable]
public class UserTwitchInfo : PlayFabBaseModel
{
///
/// Twitch ID
///
public string TwitchId;
///
/// Twitch Username
///
public string TwitchUserName;
}
[Serializable]
public class UserXboxInfo : PlayFabBaseModel
{
///
/// XBox user ID
///
public string XboxUserId;
///
/// XBox user sandbox
///
public string XboxUserSandbox;
}
[Serializable]
public class ValidateAmazonReceiptRequest : PlayFabRequestCommon
{
///
/// Catalog version of the fulfilled items. If null, defaults to the primary catalog.
///
public string CatalogVersion;
///
/// Currency used to pay for the purchase (ISO 4217 currency code).
///
public string CurrencyCode;
///
/// The optional custom tags associated with the request (e.g. build number, external trace identifiers, etc.).
///
public Dictionary CustomTags;
///