Title Region Command Reference

📌 Tips

PGOS provides two sets of CLI commands, one is the command of the PGOS title region, and the other is the command of the PGOS title global. The content displayed in the current file is the command of the PGOS title region.

If you use the CLI HTTP API method to use, please use the Title Region CLI API Domain to access.

Title Region Config Data Interface

list-title-region-config-data

cli-load-json

{}

output

{
  "Count": "the number of title region config data, type is number",
  "List": [
    {
      "ServerOnly": "the permission of title region config data, type is boolean",
      "IsJson": "the type of title region config data, type is boolean",
      "Key": "the key of title region config data, type is string",
      "Value": "the value of title region config data, type is string",
      "Description": "the description of title region config data, type is string"
    }
  ]
}

create-title-region-config-data

cli-load-json

{
  "Key": "required, the key of title region config data, type is string, max-length: 128 chars",
  "ServerOnly": "required, the permission(server only) of title region config data, type is boolean",
  "IsJson": "required, the type of title region config data, type is boolean",
  "Description": "optional, the description of title region config data, type is string, max-length: 255 chars",
  "Value": "required, the value of title region config data (If the field IsJson is set to True, the string serialized Json object needs to be passed in here.), type is string, max-length: 1 * 1024 * 1024 chars"
}

output

{
  "Key": "the key of title region config data, type is string",
  "ServerOnly": "the permission(server only) of title region config data, type is boolean",
  "IsJson": "the type of title region config data, type is boolean",
  "Description": "the description of title region config data, type is string",
  "Value": "the value of title region config data, type is string"
}

✨️ Request Example

{}

update-title-region-config-data

cli-load-json

{
  "Key": "required, the key of title region config data, type is string, max-length: 128 chars",
  "ServerOnly": "required, the permission(server only) of title region config data, type is boolean",
  "IsJson": "required, the type of title region config data, type is boolean",
  "Description": "optional, the description of title region config data, type is string, max-length: 255 chars",
  "Value": "required, the value of title region config data (If the field IsJson is set to True, the string serialized Json object needs to be passed in here.), type is string, max-length: 1 * 1024 * 1024 chars"
}

output

{
  "Count": "the title region config data number of successfully update. type is type is number"
}

delete-title-region-config-data

cli-load-json

{
  "Keys": ["required, the key of title region config data, type is string"]
}

output

{
  "Count": "the title region config data number of successfully deleting, type is number"
}

export-title-region-config-data-json-content

cli-load-json

{}

output

{
  "Count": "the number of title region config data, type is number",
  "List": [
    {
      "Key": "the key of title region config data, type is string",
      "Value": "the value of title region config data, type is string",
      "ServerOnly": "the permission(server only) of title region config data, type is boolean",
      "IsJson": "the type of title region config data, type is boolean",
      "Description": "the description of title region config data, type is string",
      "CreatedTime": "the created time of the virtual server, type is string, use ISO 8601 date format",
      "UpdatedTime": "the updated time of the virtual server, type is string, use ISO 8601 date format"
    }
  ]
}

import-title-region-config-data-json-content

cli-load-json

{
  "JsonContent": [
    {
      "Key": "required, the key of title region config data, type is string",
      "Value": "required, the value of title region config data, type is string",
      "ServerOnly": "required, the permission(server only) of title region config data, type is boolean",
      "IsJson": "required, the type of title region config data, type is boolean",
      "Description": "optional, the description of title region config data, type is string"
    }
  ]
}

output

{
  "EffectKeys": ["the effected key of import title region config data. type is string"]
}

Player KV Data Template Interface

get-all-player-kv-data-tpl

cli-load-json

{}

output

{
  "Keys": [
    {
      "Key": "the key of player data template, type is string",
      "Type": "the type of the player data template value, type is string",
      "DefaultValue": "the default value of the key, type is string",
      "ServerOnly": "the data can only be accessed by the server, type is boolean",
      "ClientWritable": "the data can be modified by the data owner on the client, type is boolean",
      "ClientPublic": "the data is visible to other players, type is boolean",
      "Description": "the description of the player data template, type is string"
    }
  ],
  "Groups": [
    {
      "GroupID": "the id of group, type is number",
      "Name": "the name of group, type is string",
      "Keys": ["the key of player data template, type is string"]
    }
  ]
}

set-player-kv-data-tpl

cli-load-json

{
  "Add": [
    {
      "Key": "required, the key of player data template, type is string",
      "Type": "required, the type of player data template key and can be String,Integer or Float",
      "DefaultValue": "required, the default value of the key, type is string",
      "ServerOnly": "required, the data can only be accessed by the server, type is boolean",
      "ClientWritable": "required, the data can be modified by the data owner on the client, type is boolean",
      "ClientPublic": "required, the data is visible to other players, type is boolean",
      "Description": "optional, the description of the player data template, type is string"
    }
  ],
  "Update": [
    {
      "Key": "required, the key of player data template, type is string",
      "DefaultValue": "required, the default value of the key, type is string",
      "ServerOnly": "required, the data can only be accessed by the server, type is boolean",
      "ClientWritable": "required, the data can be modified by the data owner on the client, type is boolean",
      "ClientPublic": "required, the data is visible to other players, type is boolean",
      "Description": "optional, the description of the player data template, type is string"
    }
  ],
  "Remove": ["required, the key of player data template, type is string"]
}

output

[
  {
    "Key": "the key of player data template, type is string",
    "Type": "the type of player data template key, type is string",
    "DefaultValue": "the default value of the key, type is string",
    "ServerOnly": "the data can only be accessed by the server, type is boolean",
    "ClientWritable": "the data can be modified by the data owner on the client, type is boolean",
    "ClientPublic": "the data is visible to other players, type is boolean",
    "Description": "the description of the player data template, type is string"
  }
]

add-player-kv-data-group

cli-load-json

{
  "Name": "required, the name of group, type is string"
}

output

{
  "Name": "the name of group, type is string",
  "GroupID": "the id of new group, type is number"
}

update-player-kv-data-group

cli-load-json

{
  "GroupID": "required, the id of group, type is number",
  "Name": "required, the new name of group, type is string"
}

output

{
  "GroupID": "the id of the group, type is number",
  "Name": "the name of group, type is string"
}

remove-player-kv-data-group

cli-load-json

{
  "GroupID": "required, the id of group, type is number"
}

output

{}

set-player-kv-data-group-keys

cli-load-json

{
  "GroupID": "required, the id of group, type is number",
  "Keys": ["required, the key of player data template, type is string"]
}

output

{}

Player Blob Data Template Interface

get-player-blob-data-tpl

cli-load-json

{}

output

[
  {
    "Key": "the key of player blob data template. type is string",
    "ServerOnly": "the data can only be accessed by the server. type is boolean",
    "ClientWritable": "the data can be modified by the data owner on the client. type is boolean",
    "ClientPublic": "the data is visible to other players. type is boolean",
    "Description": "the description of the player blob data template. type is string"
  }
]

set-player-blob-data-tpl

cli-load-json

{
  "Add": [
    {
      "Key": "required, the key of player blob data template. type is string",
      "ServerOnly": "required, the data can only be accessed by the server. type is boolean",
      "ClientWritable": "required, the data can be modified by the data owner on the client. type is boolean",
      "ClientPublic": "required, the data is visible to other players. type is boolean",
      "Description": "optional, the description of the player blob data template. type is string"
    }
  ],
  "Update": [
    {
      "Key": "required, the key of player blob data template. type is string",
      "ServerOnly": "required, the data can only be accessed by the server. type is boolean",
      "ClientWritable": "required, the data can be modified by the data owner on the client. type is boolean",
      "ClientPublic": "required, the data is visible to other players. type is boolean",
      "Description": "optional, the description of the player blob data template. type is string"
    }
  ],
  "Remove": ["required, the key of player blob data template"]
}

output

[
  {
    "Key": "the key of player blob data template. type is string",
    "ServerOnly": "the data can only be accessed by the server. type is boolean",
    "ClientWritable": "the data can be modified by the data owner on the client. type is boolean",
    "ClientPublic": "the data is visible to other players. type is boolean",
    "Description": "the description of the player blob data template. type is string"
  }
]

Player Custom Info Definition Interface

export-player-custom-info-definition

cli-load-json

{}

output

{
  "Total": "the total of the player custom info definition, type is number",
  "PlayerKVDataKeys": ["the key of the player custom info definition, type is string"],
  "PlayerKVDataList": [
    {
      "Key": "the key of the player custom info definition, type is string",
      "Type": "the type of the player custom info definition, type is string",
      "DefaultValue": "the default value of the player custom info definition, type is string",
      "Description": "the description of the player custom info definition, type is string",
      "ClientPublic": "the client public of the player custom info definition, type is boolean",
      "ClientWritable": "the client writable of the player custom info definition, type is boolean",
      "ServerOnly": "the server only of the player custom info definition, type is boolean",
      "Versioned": "the versioned of the player custom info definition, type is boolean"
    }
  ]
}

import-player-custom-info-definition

cli-load-json

{
  "PlayerKVDataKeys": ["required, the key of the player custom info definition, you can get it from player data command, type is string"]
}

output

{
  "PlayerKVDataKeys": ["the success key of the player custom info definition, type is string"]
}

DS Hosting Interface

list-build

cli-load-json

{
  "SearchKey": "optional, the build id or name to search. type is string",
  "Count": "optional, the maximum number of results to return. type is number",
  "Offset": "optional, the offset number of data items returned per page, type is number"
}

output

{
  "Total": "the number of build results. type is number",
  "List": [
    {
      "Id": "the build id",
      "Name": "the build name",
      "Version": "the build version",
      "OperateSystem": "the build operate system",
      "Md5": "the checksum values of build file, by md5 algorithm",
      "Size": "the size of the build file"
    }
  ]
}

create-build

cli-load-json

{
  "Name": "required, build name, type is string",
  "Version": "required, build version, type is string",
  "OperateSystem": "required, operate system value, optional value is Linux/Windows, only support Linux now, type is string",
  "Md5": "required, build file md5 value, type is string",
  "Size": "required, build file size, type is number"
}

output

{
  "Id": "build id, type is string",
  "Name": "build name, type is string",
  "Version": "build version, type is string",
  "OperateSystem": "operate system value, eg:Linux or Windows, type is string"
}

cli-upload-files

[
  {
    "path": "upload file path,type is string",
    "label": "BucketKey"
  }
];

The label field must be BucketKey.

update-build

cli-load-json

{
  "Id": "required, the build id. type is string",
  "Name": "required, build name, type is string",
  "Version": "required, build version, type is string"
}

output

{
  "Id": "build id, type is string",
  "Name": "build name, type is string",
  "Version": "build version, type is string"
}

describe-build

cli-load-json

{
  "Id": "required, the build id. type is string"
}

output

{
  "Id": "the build id",
  "Name": "the build name",
  "Version": "the build version",
  "OperateSystem": "the build operate system",
  "Md5": "the checksum values of build file, by md5 algorithm",
  "Size": "the size of the build file"
}

delete-build

cli-load-json

{
  "Id": "required, the build id. type is string"
}

output

{}

list-available-idc

cli-load-json

{}

output

[
  {
    "CloudProvider": "the type of cloud provider, type is string",
    "IDCs": [
      {
        "Name": "the name of IDC cloud provider, type is string",
        "Code": "the code of IDC cloud provider, type is string",
        "Lon": "the lon of IDC cloud provider, type is number",
        "Lat": "the lat of IDC cloud provider, type is number"
      }
    ]
  }
]

list-cvm-instance-type

cli-load-json

{}

output

[
  {
    "CloudProvider": "the type of cloud provider, type is string",
    "CvmInstances": [
      {
        "IDC": "the code of IDC cloud provider, type is string",
        "AvailableCVMs": [
          {
            "InstanceID": "the id of CVM instance, type is string",
            "InstanceType": "the type of CVM instance, type is string",
            "Zone": "the zone of CVM instance, type is string",
            "Cpu": "the CPU number of CVM instance, type is number",
            "Memory": "the Memory of CVM instance, type is number",
            "IsSoldOut": "the CVM instance is sold out or not, type is boolean"
          }
        ]
      }
    ]
  }
]

list-available-zone

cli-load-json

{}

output

[
  {
    "Zone": "the zone of cloud provider, type is string",
    "AvailableDataCenters": [
      {
        "Name": "the name of cloud provider data center, type is string",
        "Code": "the code of cloud provider data center, type is string",
        "Lon": "the lon of cloud provider data center, type is number",
        "Lat": "the lat of cloud provider data center, type is number",
        "Zone": "the zone of cloud provider data center, type is string",
        "MachineType": "the type of machine, CVM or BareMetal, type is string"
      }
    ]
  }
]

list-available-data-center

cli-load-json

{}

output

[
  {
    "CloudProvider": "the type of cloud provider, type is string",
    "DataCenters": [
      {
        "Name": "the name of cloud provider data center, type is string",
        "Code": "the code of cloud provider data center, type is string",
        "Lon": "the lon of cloud provider data center, type is number",
        "Lat": "the lat of cloud provider data center, type is number",
        "Zone": "the zone of cloud provider data center, type is string",
        "MachineType": "the type of machine, CVM or BareMetal, type is string"
      }
    ]
  }
]

create-fleet

cli-load-json

{
  "FleetName": "required, the name of fleet, type is string",
  "Description": "optional, the description of fleet, type is string",
  "BuildConfiguration": {
    "MainBuild": {
      "BuildID": "required, the id of fleet associated build, type is string"
    },
    "UpdateMode": "required, the update mode of fleet build config, type is number, optional data: 0-Force Update, 1-Safe Update"
  },
  "DeploymentConfiguration": {
    "Zones": [
      {
        "Zone": "required, the zone of fleet deployment config, type is string, eg: EU Central",
        "DataCenters": [
          {
            "IDC": "required, the idc of fleet deployment config, type is string, eg: eu-central-1",
            "CloudProvider": "required, the cloud provider of fleet deployment config, type is string, eg: tcloud",
            "MachineType": "required, the machine type of fleet deployment config, type is string, optional data: \"Virtual Machine\" / \"Bare Metal\"",
            "MachineModels": ["required, the machine model (instance id, you can get throw \"list-cvm-instance-type\" interface) of fleet deployment config, type is string, eg: S5.LARGE4"],
            "BareMetalMachinesCount": ["required, the number of bare metal machines of fleet deployment config, only available when MachineType is \"Bare Metal\", type is number"],
            "MaxServerProcesses": "required, the max server processes of fleet deployment config, type is number",
            "Priority": "required, the priority of fleet deployment config, 1-Hign/2-Medium/3-Low, type is number"
          }
        ],
        "ScalingStrategy": {
          "ScalingMode": "required, the scaling mode of fleet deployment config, type is string, optional data: \"Fixed Server Processes\" / \"Auto Scaling With Buffer\"",
          "FixedServerProcesses": {},
          "AutoScalingWithBuffer": {
            "InitialServerProcesses": "required, the initial server processes of fleet deployment config, type is number",
            "BufferRule": "required, the buffer rule of fleet deployment config, type is string, optional data: \"Single Rule\" / \"Segment Rule\"",
            "SingleRule": {
              "Rule": {
                "UseProportion": "required, whether to use proportion mode to calculate the number of servers to be placed, type is boolean",
                "KeepAvailableServers": "required, the keep available servers of fleet deployment config, type is number",
                "KeepAvailableProportion": "required, the keep available proportion of fleet deployment config, type is number"
              }
            },
            "SegmentRule": {
              "Segments": [
                {
                  "MinPlacedServers": "required, the min placed servers of fleet deployment config, type is number",
                  "MaxPlacedServers": "required, the max placed servers of fleet deployment config, the lastest segment max placed servers must be 4294967295 means Infinity, type is number",
                  "Rule": {
                    "UseProportion": "required, whether to use proportion mode to calculate the number of servers to be placed, type is boolean",
                    "KeepAvailableServers": "required, the keep available servers of fleet deployment config, type is number",
                    "KeepAvailableProportion": "required, the keep available proportion of fleet deployment config, type is number"
                  }
                }
              ]
            }
          },
          "CooldownTime": "required, the cooldown time of fleet deployment config, 0 means no cooldown, type is number"
        }
      }
    ],
    "DSCountInMachines": [
      {
        "CloudProvider": "required, the cloud provider of fleet deployment config, type is string, eg: tcloud",
        "MachineModel": "required, the machine model (instance id, you can get throw \"list-cvm-instance-type\" interface) of fleet deployment config, type is string, eg: S5.LARGE4",
        "DSCount": "required, the ds count of fleet deployment config, type is number"
      }
    ]
  },
  "ProcessConfiguration": {
    "RestartProcessTime": "required, the time of restart even if no placement, type is number, unit: Hour",
    "LaunchPath": "required, the launch path of process, must not be a script file(.sh/.bat/.ps1), type is string",
    "LaunchParam": "required, the launch parameter of process, type is string"
  },
  "FirewallConfiguration": {
    "InboundRange": [
      {
        "BeginPort": "the begin port of the firewall network, type is number",
        "EndPort": "the end port of the firewall network, type is number",
        "IPRange": "the IP range of the firewall network, type is string, eg: 0.0.0.0/0",
        "Protocol": "the protocol of the firewall network, type is string, optional data: \"TCP\" / \"UDP\""
      }
    ]
  }
}

output

{
  "FleetID": "the id of fleet, type is string",
  "FleetName": "the name of fleet, type is string",
  "Description": "the description of fleet, type is string",
  "Status": "the status of fleet, New, Launching, Cooldown, Available, Deleting, Unavailable, Terminated, type is string",
  "CreatedTime": "the created time of fleet, type is string (format: ISO time, eg: 2022-09-01T07:31:40.000Z)",
  "BuildConfiguration": {
    "MainBuild": {
      "BuildID": "the id of fleet associated build, type is string"
    },
    "UpdateMode": "the update mode of fleet build config, type is number, optional data: 0-Force Update, 1-Safe Update"
  },
  "DeploymentConfiguration": {
    "Zones": [
      {
        "Zone": "the zone of fleet deployment config, type is string, eg: EU Central",
        "DataCenters": [
          {
            "IDC": "the idc of fleet deployment config, type is string, eg: eu-central-1",
            "CloudProvider": "the cloud provider of fleet deployment config, type is string, eg: tcloud",
            "MachineType": "the machine type of fleet deployment config, type is string, optional data: \"Virtual Machine\" / \"Bare Metal\"",
            "MachineModels": ["the machine model (instance id, you can get throw \"list-cvm-instance-type\" interface) of fleet deployment config, type is string, eg: S5.LARGE4"],
            "BareMetalMachinesCount": ["the number of bare metal machines of fleet deployment config, only available when MachineType is \"Bare Metal\", type is number"],
            "MaxServerProcesses": "the max server processes of fleet deployment config, type is number",
            "Priority": "the priority of fleet deployment config, 1-Hign/2-Medium/3-Low, type is number"
          }
        ],
        "ScalingStrategy": {
          "ScalingMode": "the scaling mode of fleet deployment config, type is string, optional data: \"Fixed Server Processes\" / \"Auto Scaling With Buffer\"",
          "FixedServerProcesses": {},
          "AutoScalingWithBuffer": {
            "InitialServerProcesses": "the initial server processes of fleet deployment config, type is number",
            "BufferRule": "the buffer rule of fleet deployment config, type is string, optional data: \"Single Rule\" / \"Segment Rule\"",
            "SingleRule": {
              "Rule": {
                "UseProportion": "whether to use proportion mode to calculate the number of servers to be placed, type is boolean",
                "KeepAvailableServers": "the keep available servers of fleet deployment config, type is number",
                "KeepAvailableProportion": "the keep available proportion of fleet deployment config, type is number"
              }
            },
            "SegmentRule": {
              "Segments": [
                {
                  "MinPlacedServers": "the min placed servers of fleet deployment config, type is number",
                  "MaxPlacedServers": "the max placed servers of fleet deployment config, the lastest segment max placed servers must be 4294967295 means Infinity, type is number",
                  "Rule": {
                    "UseProportion": "whether to use proportion mode to calculate the number of servers to be placed, type is boolean",
                    "KeepAvailableServers": "the keep available servers of fleet deployment config, type is number",
                    "KeepAvailableProportion": "the keep available proportion of fleet deployment config, type is number"
                  }
                }
              ]
            }
          },
          "CooldownTime": "the cooldown time of fleet deployment config, type is number"
        }
      }
    ],
    "DSCountInMachines": [
      {
        "CloudProvider": "the cloud provider of fleet deployment config, type is string, eg: tcloud",
        "MachineModel": "the machine model (instance id, you can get throw \"list-cvm-instance-type\" interface) of fleet deployment config, type is string, eg: S5.LARGE4",
        "DSCount": "the ds count of fleet deployment config, type is number"
      }
    ]
  },
  "ProcessConfiguration": {
    "RestartProcessTime": "the time of restart even if no placement, type is number, unit: Hour",
    "LaunchPath": "the launch path of process, must not be a script file(.sh/.bat/.ps1), type is string",
    "LaunchParam": "the launch parameter of process, type is string"
  },
  "FirewallConfiguration": {
    "InboundRange": [
      {
        "BeginPort": "the begin port of the firewall network, type is number",
        "EndPort": "the end port of the firewall network, type is number",
        "IPRange": "the IP range of the firewall network, type is string, eg: 0.0.0.0/0",
        "Protocol": "the protocol of the firewall network, type is string, optional data: \"TCP\" / \"UDP\""
      }
    ]
  }
}

delete-fleet

cli-load-json

{
  "FleetID": "required, the id of fleet, type is string"
}

output

{}

list-fleet

cli-load-json

{
  "SearchKey": "optional, the name or id of fleet, type is string",
  "Count": "optional, the limit number of data items returned per page, type is number",
  "Offset": "optional, the offset number of data items returned per page, type is number"
}

output

{
  "Total": "the total number of fleet, type is number",
  "List": [
    {
      "FleetID": "the id of fleet, type is string",
      "FleetName": "the name of fleet, type is string",
      "Description": "the description of fleet, type is string",
      "Status": "the status of fleet, New, Launching, Cooldown, Available, Deleting, Unavailable, Terminated, type is string",
      "CreatedTime": "the created time of fleet, type is string (format: ISO time, eg: 2022-09-01T07:31:40.000Z)",
      "BuildConfiguration": {
        "MainBuild": {
          "BuildID": "the id of fleet associated build, type is string"
        },
        "UpdateMode": "the update mode of fleet build config, type is number, optional data: 0-Force Update, 1-Safe Update"
      },
      "DeploymentConfiguration": {
        "Zones": [
          {
            "Zone": "the zone of fleet deployment config, type is string, eg: EU Central",
            "DataCenters": [
              {
                "IDC": "the idc of fleet deployment config, type is string, eg: eu-central-1",
                "CloudProvider": "the cloud provider of fleet deployment config, type is string, eg: tcloud",
                "MachineType": "the machine type of fleet deployment config, type is string, optional data: \"Virtual Machine\" / \"Bare Metal\"",
                "MachineModels": ["the machine model (instance id, you can get throw \"list-cvm-instance-type\" interface) of fleet deployment config, type is string, eg: S5.LARGE4"],
                "BareMetalMachinesCount": ["the number of bare metal machines of fleet deployment config, only available when MachineType is \"Bare Metal\", type is number"],
                "MaxServerProcesses": "the max server processes of fleet deployment config, type is number",
                "Priority": "the priority of fleet deployment config, 1-Hign/2-Medium/3-Low, type is number"
              }
            ],
            "ScalingStrategy": {
              "ScalingMode": "the scaling mode of fleet deployment config, type is string, optional data: \"Fixed Server Processes\" / \"Auto Scaling With Buffer\"",
              "FixedServerProcesses": {},
              "AutoScalingWithBuffer": {
                "InitialServerProcesses": "the initial server processes of fleet deployment config, type is number",
                "BufferRule": "the buffer rule of fleet deployment config, type is string, optional data: \"Single Rule\" / \"Segment Rule\"",
                "SingleRule": {
                  "Rule": {
                    "UseProportion": "whether to use proportion mode to calculate the number of servers to be placed, type is boolean",
                    "KeepAvailableServers": "the keep available servers of fleet deployment config, type is number",
                    "KeepAvailableProportion": "the keep available proportion of fleet deployment config, type is number"
                  }
                },
                "SegmentRule": {
                  "Segments": [
                    {
                      "MinPlacedServers": "the min placed servers of fleet deployment config, type is number",
                      "MaxPlacedServers": "the max placed servers of fleet deployment config, the lastest segment max placed servers must be 4294967295 means Infinity, type is number",
                      "Rule": {
                        "UseProportion": "whether to use proportion mode to calculate the number of servers to be placed, type is boolean",
                        "KeepAvailableServers": "the keep available servers of fleet deployment config, type is number",
                        "KeepAvailableProportion": "the keep available proportion of fleet deployment config, type is number"
                      }
                    }
                  ]
                }
              },
              "CooldownTime": "the cooldown time of fleet deployment config, type is number"
            }
          }
        ],
        "DSCountInMachines": [
          {
            "CloudProvider": "the cloud provider of fleet deployment config, type is string, eg: tcloud",
            "MachineModel": "the machine model (instance id, you can get throw \"list-cvm-instance-type\" interface) of fleet deployment config, type is string, eg: S5.LARGE4",
            "DSCount": "the ds count of fleet deployment config, type is number"
          }
        ]
      },
      "ProcessConfiguration": {
        "RestartProcessTime": "the time of restart even if no placement, type is number, unit: Hour",
        "LaunchPath": "the launch path of process, must not be a script file(.sh/.bat/.ps1), type is string",
        "LaunchParam": "the launch parameter of process, type is string"
      },
      "FirewallConfiguration": {
        "InboundRange": [
          {
            "BeginPort": "the begin port of the firewall network, type is number",
            "EndPort": "the end port of the firewall network, type is number",
            "IPRange": "the IP range of the firewall network, type is string, eg: 0.0.0.0/0",
            "Protocol": "the protocol of the firewall network, type is string, optional data: \"TCP\" / \"UDP\""
          }
        ]
      }
    }
  ]
}

describe-fleet

cli-load-json

{
  "FleetID": "required, the id of fleet, type is string"
}

output

{
  "FleetID": "the id of fleet, type is string",
  "FleetName": "the name of fleet, type is string",
  "Description": "the description of fleet, type is string",
  "Status": "the status of fleet, New, Launching, Cooldown, Available, Deleting, Unavailable, Terminated, type is string",
  "CreatedTime": "the created time of fleet, type is string (format: ISO time, eg: 2022-09-01T07:31:40.000Z)",
  "BuildConfiguration": {
    "MainBuild": {
      "BuildID": "the id of fleet associated build, type is string"
    },
    "UpdateMode": "the update mode of fleet build config, type is number, optional data: 0-Force Update, 1-Safe Update"
  },
  "DeploymentConfiguration": {
    "Zones": [
      {
        "Zone": "the zone of fleet deployment config, type is string, eg: EU Central",
        "DataCenters": [
          {
            "IDC": "the idc of fleet deployment config, type is string, eg: eu-central-1",
            "CloudProvider": "the cloud provider of fleet deployment config, type is string, eg: tcloud",
            "MachineType": "the machine type of fleet deployment config, type is string, optional data: \"Virtual Machine\" / \"Bare Metal\"",
            "MachineModels": ["the machine model (instance id, you can get throw \"list-cvm-instance-type\" interface) of fleet deployment config, type is string, eg: S5.LARGE4"],
            "BareMetalMachinesCount": ["the number of bare metal machines of fleet deployment config, only available when MachineType is \"Bare Metal\", type is number"],
            "MaxServerProcesses": "the max server processes of fleet deployment config, type is number",
            "Priority": "the priority of fleet deployment config, 1-Hign/2-Medium/3-Low, type is number"
          }
        ],
        "ScalingStrategy": {
          "ScalingMode": "the scaling mode of fleet deployment config, type is string, optional data: \"Fixed Server Processes\" / \"Auto Scaling With Buffer\"",
          "FixedServerProcesses": {},
          "AutoScalingWithBuffer": {
            "InitialServerProcesses": "the initial server processes of fleet deployment config, type is number",
            "BufferRule": "the buffer rule of fleet deployment config, type is string, optional data: \"Single Rule\" / \"Segment Rule\"",
            "SingleRule": {
              "Rule": {
                "UseProportion": "whether to use proportion mode to calculate the number of servers to be placed, type is boolean",
                "KeepAvailableServers": "the keep available servers of fleet deployment config, type is number",
                "KeepAvailableProportion": "the keep available proportion of fleet deployment config, type is number"
              }
            },
            "SegmentRule": {
              "Segments": [
                {
                  "MinPlacedServers": "the min placed servers of fleet deployment config, type is number",
                  "MaxPlacedServers": "the max placed servers of fleet deployment config, the lastest segment max placed servers must be 4294967295 means Infinity, type is number",
                  "Rule": {
                    "UseProportion": "whether to use proportion mode to calculate the number of servers to be placed, type is boolean",
                    "KeepAvailableServers": "the keep available servers of fleet deployment config, type is number",
                    "KeepAvailableProportion": "the keep available proportion of fleet deployment config, type is number"
                  }
                }
              ]
            }
          },
          "CooldownTime": "the cooldown time of fleet deployment config, type is number"
        }
      }
    ],
    "DSCountInMachines": [
      {
        "CloudProvider": "the cloud provider of fleet deployment config, type is string, eg: tcloud",
        "MachineModel": "the machine model (instance id, you can get throw \"list-cvm-instance-type\" interface) of fleet deployment config, type is string, eg: S5.LARGE4",
        "DSCount": "the ds count of fleet deployment config, type is number"
      }
    ]
  },
  "ProcessConfiguration": {
    "RestartProcessTime": "the time of restart even if no placement, type is number, unit: Hour",
    "LaunchPath": "the launch path of process, must not be a script file(.sh/.bat/.ps1), type is string",
    "LaunchParam": "the launch parameter of process, type is string"
  },
  "FirewallConfiguration": {
    "InboundRange": [
      {
        "BeginPort": "the begin port of the firewall network, type is number",
        "EndPort": "the end port of the firewall network, type is number",
        "IPRange": "the IP range of the firewall network, type is string, eg: 0.0.0.0/0",
        "Protocol": "the protocol of the firewall network, type is string, optional data: \"TCP\" / \"UDP\""
      }
    ]
  }
}

update-fleet-attributes

cli-load-json

{
  "FleetID": "required, the id of fleet, type is string",
  "FleetName": "required, the name of fleet, type is string",
  "Description": "required, the description of fleet, type is string",
  "BuildConfiguration": {
    "MainBuild": {
      "BuildID": "required, the id of fleet associated build, type is string"
    },
    "UpdateMode": "required, the update mode of fleet build config, type is number, optional data: 0-Force Update, 1-Safe Update"
  },
  "DeploymentConfiguration": {
    "Zones": [
      {
        "Zone": "required, the zone of fleet deployment config, type is string, eg: EU Central",
        "DataCenters": [
          {
            "IDC": "required, the idc of fleet deployment config, type is string, eg: eu-central-1",
            "CloudProvider": "required, the cloud provider of fleet deployment config, type is string, eg: tcloud",
            "MachineType": "required, the machine type of fleet deployment config, type is string, optional data: \"Virtual Machine\" / \"Bare Metal\"",
            "MachineModels": ["required, the machine model (instance id, you can get throw \"list-cvm-instance-type\" interface) of fleet deployment config, type is string, eg: S5.LARGE4"],
            "BareMetalMachinesCount": ["required, the number of bare metal machines of fleet deployment config, only available when MachineType is \"Bare Metal\", type is number"],
            "MaxServerProcesses": "required, the max server processes of fleet deployment config, type is number",
            "Priority": "required, the priority of fleet deployment config, 1-Hign/2-Medium/3-Low, type is number"
          }
        ],
        "ScalingStrategy": {
          "ScalingMode": "required, the scaling mode of fleet deployment config, type is string, optional data: \"Fixed Server Processes\" / \"Auto Scaling With Buffer\"",
          "FixedServerProcesses": {},
          "AutoScalingWithBuffer": {
            "InitialServerProcesses": "required, the initial server processes of fleet deployment config, type is number",
            "BufferRule": "required, the buffer rule of fleet deployment config, type is string, optional data: \"Single Rule\" / \"Segment Rule\"",
            "SingleRule": {
              "Rule": {
                "UseProportion": "required, whether to use proportion mode to calculate the number of servers to be placed, type is boolean",
                "KeepAvailableServers": "required, the keep available servers of fleet deployment config, type is number",
                "KeepAvailableProportion": "required, the keep available proportion of fleet deployment config, type is number"
              }
            },
            "SegmentRule": {
              "Segments": [
                {
                  "MinPlacedServers": "required, the min placed servers of fleet deployment config, type is number",
                  "MaxPlacedServers": "required, the max placed servers of fleet deployment config, the lastest segment max placed servers must be 4294967295 means Infinity, type is number",
                  "Rule": {
                    "UseProportion": "required, whether to use proportion mode to calculate the number of servers to be placed, type is boolean",
                    "KeepAvailableServers": "required, the keep available servers of fleet deployment config, type is number",
                    "KeepAvailableProportion": "required, the keep available proportion of fleet deployment config, type is number"
                  }
                }
              ]
            }
          },
          "CooldownTime": "required, the cooldown time of fleet deployment config, 0 means no cooldown, type is number"
        }
      }
    ],
    "DSCountInMachines": [
      {
        "CloudProvider": "required, the cloud provider of fleet deployment config, type is string, eg: tcloud",
        "MachineModel": "required, the machine model (instance id, you can get throw \"list-cvm-instance-type\" interface) of fleet deployment config, type is string, eg: S5.LARGE4",
        "DSCount": "required, the ds count of fleet deployment config, type is number"
      }
    ]
  },
  "ProcessConfiguration": {
    "RestartProcessTime": "required, the time of restart even if no placement, type is number, unit: Hour",
    "LaunchPath": "required, the launch path of process, must not be a script file(.sh/.bat/.ps1), type is string",
    "LaunchParam": "required, the launch parameter of process, type is string"
  },
  "FirewallConfiguration": {
    "InboundRange": [
      {
        "BeginPort": "the begin port of the firewall network, type is number",
        "EndPort": "the end port of the firewall network, type is number",
        "IPRange": "the IP range of the firewall network, type is string, eg: 0.0.0.0/0",
        "Protocol": "the protocol of the firewall network, type is string, optional data: \"TCP\" / \"UDP\""
      }
    ]
  }
}

output

{}

list-fleet-cvm-instance

cli-load-json

{
  "FleetID": "required, the id of fleet, type is string",
  "CVMInstanceID": "required, the id of fleet cvm instance, type is string",
  "Offset": "required, the offset of list, type is number",
  "Count": "required, the limit of list, type is number"
}

output

{
  "Total": "the total count of fleet cvm instance, type is number",
  "NextOffset": "the next offset of list, type is number",
  "List": [
    {
      "CVMInstanceID": "the id of fleet cvm instance, type is string",
      "Status": "the status of fleet cvm instance, type is string",
      "PlacedDS": "the placed ds of fleet cvm instance, type is string",
      "TotalDS": "the total ds of fleet cvm instance, type is string",
      "IDC": "the cloud idc of fleet cvm instance, type is string",
      "BuildID": "the build id of fleet cvm instance, type is string",
      "OuterIP": "the outer ip of fleet cvm instance, type is string",
      "InnerIP": "the inner ip of fleet cvm instance, type is string",
      "CreatedTime": "the created time of fleet cvm instance, type is string (format: ISO time, eg: 2022-09-01T07:31:40.000Z)"
    }
  ]
}

list-fleet-cvm-instance-file

cli-load-json

{
  "CVMInstanceID": "required, the id of machine instance, type is string, required",
  "Directory": "required, the directory of machine instance, must start with: /local/game or C:\\local\\game, type is string, required"
}

output

[
  {
    "Name": "the name of file, type is string",
    "IsDirectory": "the file is directory or not, type is boolean",
    "IsText": "the file can be read as text or not, type is boolean",
    "ModifiedTime": "the modified time of file, type is string (format: ISO time, eg: 2022-09-01T07:31:40.000Z)",
    "Size": "the size of file (Byte), type is number",
    "SizeMB": "the size of file (MB), type is string"
  }
]

collect-fleet-cvm-instance-file

cli-load-json

{
  "CVMInstanceID": "required, the id of machine instance, type is string, required",
  "Paths": ["required, the path of file or directory, must start with: /local/game or C:\\local\\game, type is string, required"]
}

output

{
  "CollectID": "the id of collect operation, type is string"
}

cancel-fleet-cvm-instance-file-collection

cli-load-json

{
  "CVMInstanceID": "required, the id of machine instance, type is string, required",
  "CollectID": "required, the id of collect operation, type is string, required"
}

output

{}

describe-fleet-cvm-instance-file-collection

提示

The operation of collecting files is asynchronous. You need to poll this command to query the collection result until the collection result status (Status) is Completed, and then you can get the download address of the file (CloudFileDownloadURL).

cli-load-json

{
  "CVMInstanceID": "required, the id of machine instance, type is string, required",
  "CollectID": "required, the id of collect operation, type is string, required"
}

output

{
  "Status": "the status of collect operation, options: Collecting/Completed, type is string",
  "CloudFileDownloadURL": "the download url of collected file(only available when status is Completed), type is string",
  "CloudFileDestination": {
    "Provider": "the provider of cloud file, type is string",
    "DataCenter": "the data center of cloud file, type is string",
    "Bucket": "the bucket of cloud file, type is string",
    "BucketKey": "the bucket key of cloud file, type is string"
  }
}

create-placer

cli-load-json

{
  "PlacerName": "required, the name of the placer, type is string",
  "AssociatedFleetID": "required, the fleet id of the placer, type is string",
  "BattlesessionActiveTimeout": "required, when receiving the OnStartBattleSession event, the DS must call the ActivateBattleSession API within the time, type is number, optional data: 0-600.",
  "PlayerMaxLatencyMS": "required, If any player has a latency > the value, no DS will be assigned for the placement. (0 means ignore this limit), type is number, optional data: 0-600.",
  "PlacementRules": [
    {
      "LatencyAlgorithm": "the algorithm of the step, type: string, optional data: `Avg Latency`, `Max Latency`, `Leader Latency`, `Avg Latency after Trimmed`",
      "MaxLatencyMs": "the max latency millisecond, type: number, optional data: 0-9999",
      "WaitingPeriodSec": "the wait seconds of the step, type: number, optional data: 0-600",
      "MinPlayerNum": "the minimum player count for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: number",
      "TrimPercent": "the trim player percent for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: number",
      "TrimEnforceOne": "whether trim player for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: boolean",
      "RoundType": "rounding type for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: string, optional data: `Round Off`,`Round Up`,`Round Down`"
    }
  ]
}

output

{
  "PlacerName": "the name of the placer, type is string",
  "AssociatedFleetID": "the fleet id of the placer, type is string",
  "BattlesessionActiveTimeout": "when receiving the OnStartBattleSession event, the DS must call the ActivateBattleSession API within the time, type is number, optional data: 0-600.",
  "PlayerMaxLatencyMS": "If any player has a latency > the value, no DS will be assigned for the placement. (0 means ignore this limit), type is number, optional data: 0-600.",
  "PlacementRules": [
    {
      "LatencyAlgorithm": "the algorithm of the step, type: string, optional data: `Avg Latency`, `Max Latency`, `Leader Latency`, `Avg Latency after Trimmed`",
      "MaxLatencyMs": "the max latency millisecond, type: number, optional data: 0-9999",
      "WaitingPeriodSec": "the wait seconds of the step, type: number, optional data: 0-600",
      "MinPlayerNum": "the minimum player count for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: number",
      "TrimPercent": "the trim player percent for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: number",
      "TrimEnforceOne": "whether trim player for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: boolean",
      "RoundType": "rounding type for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: string, optional data: `Round Off`,`Round Up`,`Round Down`"
    }
  ]
}

update-placer

cli-load-json

{
  "PlacerName": "required, the name of the placer, type is string",
  "AssociatedFleetID": "required, the fleet id of the placer, type is string",
  "BattlesessionActiveTimeout": "required, when receiving the OnStartBattleSession event, the DS must call the ActivateBattleSession API within the time, type is number, optional data: 0-600",
  "PlayerMaxLatencyMS": "required, If any player has a latency > the value, no DS will be assigned for the placement. (0 means ignore this limit), type is number, optional data: 0-600",
  "PlacementRules": [
    {
      "LatencyAlgorithm": "the algorithm of the step, type: string, optional data: `Avg Latency`, `Max Latency`, `Leader Latency`, `Avg Latency after Trimmed`",
      "MaxLatencyMs": "the max latency millisecond, type: number, optional data: 0-9999",
      "WaitingPeriodSec": "the wait seconds of the step, type: number, optional data: 0-600",
      "MinPlayerNum": "the minimum player count for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: number",
      "TrimPercent": "the trim player percent for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: number",
      "TrimEnforceOne": "whether trim player for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: boolean",
      "RoundType": "rounding type for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: string, optional data: `Round Off`,`Round Up`,`Round Down`"
    }
  ]
}

output

{}

delete-placer

cli-load-json

{
  "PlacerName": "required, the name of the placer, type is string"
}

output

{}

list-placer

cli-load-json

{
  "SearchKey": "optional, the name of placer, type is string",
  "Count": "optional, the limit number of data items returned per page, type is number",
  "Offset": "optional, the offset number of data items returned per page, type is number"
}

output

{
  "Total": "the total number of placer, type is number",
  "List": [
    {
      "PlacerName": "the name of the placer, type is string",
      "AssociatedFleetID": "the fleet id of the placer, type is string",
      "BattlesessionActiveTimeout": "when receiving the OnStartBattleSession event, the DS must call the ActivateBattleSession API within the time, type is number, optional data: 0-600",
      "PlayerMaxLatencyMS": "If any player has a latency > the value, no DS will be assigned for the placement. (0 means ignore this limit), type is number, optional data: 0-600",
      "PlacementRules": [
        {
          "LatencyAlgorithm": "the algorithm of the step, type: string, optional data: `Avg Latency`, `Max Latency`, `Leader Latency`, `Avg Latency after Trimmed`",
          "MaxLatencyMs": "the max latency millisecond, type: number, optional data: 0-9999",
          "WaitingPeriodSec": "the wait seconds of the step, type: number, optional data: 0-600",
          "MinPlayerNum": "min player num for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: number",
          "TrimPercent": "trim player percent for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: number",
          "TrimEnforceOne": "if trim player for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: boolean",
          "RoundType": "rounding type for the step, only for `Avg Latency after Trimmed` LatencyAlgorithm, type: string, optional data: `Round Off`,`Round Up`,`Round Down`"
        }
      ]
    }
  ]
}

create-local-placer

cli-load-json

{
  "PlacerName": "the name of the lcoal placer, type: string",
  "FindDSTimeout": "the timeout of find DS, optional data: 10-600, default: 60, type: number"
}

output

{
  "ID": "the id of the local placer, type: string"
}

delete-local-placer

cli-load-json

{
  "PlacerName": "the name of the lcoal placer, type: string"
}

output

{}

list-local-placer

cli-load-json

{}

output

{
  "ID": "the id of the local placer, type: string",
  "PlacerName": "the name of the lcoal placer, type: string",
  "DSCount": "the count of DS, type: number",
  "FindDSTimeout": "the timeout of find DS, optional data: 10-600, type: number",
  "CreatedTime": "the created time of local placer, type: string (format: ISO time, eg: 2022-09-01T07:31:40.000Z)"
}

Matchmaking Interface

list-match-config

cli-load-json

{
  "Name": "optional, the name of match config, type is string",
  "Limit": "optional, the number of result, type is number",
  "Offset": "optional, the offset of result, type is number"
}

output

{
  "Count": "the count of match config, type is number",
  "List": [
    {
      "Name": "the name of match config, type is string",
      "Description": "the description of match config, type is string",
      "Placer": "the placer name, type is string",
      "Provider": "the provider of placer, type is string, value:pgos | pgos_local_placer",
      "MultiRulesetEnabled": "the switch of multi ruleset, value: disable | enable, type is string",
      "MultiRulesets": [
        {
          "Provider": "the provider of placer, type is string, value:pgos | pgos_local_placer",
          "RulesetName": "the name of ruleset, type is string",
          "Placer": "the placer name, type is string"
        }
      ],
      "PreparingTimeout": "the number of second for preparing timeout, type is number",
      "SearchingTimeout": "the number of second for searching timeout, type is number",
      "BattleSessionData": "the data of match config, type is string",
      "GameProperty": ["the object of game property, type is object"],
      "Acceptance": "the switch of acceptance, value: disable | enable, type is string",
      "AcceptingTimeout": "the number of second for accepting, if set Acceptance 1, type is number",
      "AutoContinue": "the switch of acceptance, mutually exclusive with AutoBackfill, value: disable | enable, type is string",
      "AutoBackfill": "the switch of acceptance, mutually exclusive with AutoContinue, value: disable | enable, type is string",
      "AssociatedRuleset": "the associated ruleset, type is string",
      "Status": "the status of match config, type is string",
      "PostProcessing": "the status of post processing of match config, value: disable | enable, type: string",
      "PostProcessingVirtualServer": "the post processing virtual server of match config, type: string",
      "CreateTime": "the create time of match config, type is string",
      "CreatedTime": "the create time of match config, type is string",
      "UpdatedTime": "the update time of match config, type is string"
    }
  ]
}

describe-match-config

cli-load-json

{
  "Name": "required, the name of match config, type is string"
}

output

{
  "Name": "the name of match config, type is string",
  "Description": "the description of match config, type is string",
  "Placer": "the placer name, type is string",
  "Provider": "the provider of placer, type is string, value:pgos | pgos_local_placer",
  "MultiRulesetEnabled": "the switch of multi ruleset, value: disable | enable, type is string",
  "MultiRulesets": [
    {
      "Provider": "the provider of placer, type is string, value:pgos | pgos_local_placer",
      "RulesetName": "the name of ruleset, type is string",
      "Placer": "the placer name, type is string"
    }
  ],
  "PreparingTimeout": "the number of second for preparing timeout, type is number",
  "SearchingTimeout": "the number of second for searching timeout, type is number",
  "BattleSessionData": "the data of match config, type is string",
  "GameProperty": ["the object of game property, type is object"],
  "Acceptance": "the switch of acceptance, value: disable | enable, type is string",
  "AcceptingTimeout": "the number of second for accepting, if set Acceptance 1, type is number",
  "AutoContinue": "the switch of acceptance, mutually exclusive with AutoBackfill, value: disable | enable, type is string",
  "AutoBackfill": "the switch of acceptance, mutually exclusive with AutoContinue, value: disable | enable, type is string",
  "AssociatedRuleset": "the associated ruleset, type is string",
  "Status": "the status of match config, type is string",
  "PostProcessing": "the status of post processing of match config, value: disable | enable, type: string",
  "PostProcessingVirtualServer": "the post processing virtual server of match config, type: string",
  "CreateTime": "the create time of match config, type is string",
  "CreatedTime": "the create time of match config, type is string",
  "UpdatedTime": "the update time of match config, type is string"
}

create-match-config

cli-load-json

{
  "Name": "required, the name of match config, type is string",
  "AssociatedRuleset": "required, the name of ruleset. in order to solve the historical compatibility problem, you can still use RulesetName to create, but we recommend using AssociatedRuleset, type is string",
  "PreparingTimeout": "required, the number of second for preparing timeout, type is number",
  "SearchingTimeout": "required, the number of second for searching timeout, type is number",
  "Description": "optional, the description of match config, type is string",
  "Placer": "required, the name of associated placer, type is string",
  "Provider": "required, the provider of placer, type is string, value:pgos | pgos_local_placer",
  "MultiRulesetEnabled": "required, the switch of multi ruleset, value: disable | enable, type is string",
  "MultiRulesets": [
    {
      "Provider": "required, the provider of placer, type is string, value:pgos | pgos_local_placer",
      "RulesetName": "required, the name of ruleset, type is string",
      "Placer": "required, the placer name, type is string"
    }
  ],
  "BattleSessionData": "optional, the data of match config, type is string",
  "GameProperty": ["optional, the object of game property, values like [{'Key':'key','Value':'value'}],type is object"],
  "Acceptance": "required, the switch of acceptance, value: disable | enable, type is string",
  "AcceptingTimeout": "required, the number of second for accepting, if set Acceptance 1, type is number",
  "AutoContinue": "required, the switch of acceptance, mutually exclusive with AutoBackfill, value: disable | enable, type is string",
  "AutoBackfill": "required, the switch of acceptance, mutually exclusive with AutoContinue, value: disable | enable, type is string",
  "PostProcessing": "optional, the status of post processing of match config, value: disable | enable, type: string",
  "PostProcessingVirtualServer": "optional, the post processing virtual server of match config, type: string"
}

output

{
  "Name": "the name of match config, type is string",
  "Description": "the description of match config, type is string"
}

delete-match-config

cli-load-json

{
  "Name": "required, the name of match config, type is string"
}

output

{}

update-match-config

cli-load-json

{
  "Name": "required, the name of match config, type is string",
  "AssociatedRuleset": "required, the name of ruleset. in order to solve the historical compatibility problem, you can still use RulesetName to create, but we recommend using AssociatedRuleset, type is string",
  "Provider": "required, the provider of placer, type is string, value: pgos | pgos_local_placer",
  "MultiRulesetEnabled": "required, the switch of multi ruleset, value: disable | enable, type is string",
  "MultiRulesets": [
    {
      "Provider": "required, the provider of placer, type is string, value:pgos | pgos_local_placer",
      "RulesetName": "required, the name of ruleset, type is string",
      "Placer": "required, the placer name, type is string"
    }
  ],
  "PreparingTimeout": "required, the number of second for preparing timeout, type is number",
  "SearchingTimeout": "required, the number of second for searching timeout, type is number",
  "Description": "optional, the description of match config, type is string",
  "Placer": "required, the name of associated placer, type is string",
  "BattleSessionData": "optional, the data of match config, type is string",
  "GameProperty": ["optional, the object of game property, values like [{'Key':'key','Value':'value'}],type is object"],
  "Acceptance": "required, the switch of acceptance, value: disable | enable, type is number",
  "AcceptingTimeout": "required, the number of second for accepting, if set Acceptance 1, type is number",
  "AutoContinue": "required, the switch of acceptance, value: disable | enable, type is number",
  "AutoBackfill": "required, the switch of acceptance, value: disable | enable, type is number",
  "PostProcessing": "optional, the status of post processing of match config, value: disable | enable, type: string",
  "PostProcessingVirtualServer": "optional, the post processing virtual server of match config, type: string"
}

output

{}

update-match-config-status

cli-load-json

{
  "Name": "required, the name of match config, type is string",
  "Status": "required, the status of match config, value: Enabled | Disabled ,type is string"
}

output

{}

Ruleset Interface

list-match-ruleset

cli-load-json

{
  "Name": "optional, the name of ruleset, type is string",
  "Limit": "optional, the number of result, type is number",
  "Offset": "optional, the offset of result, type is number"
}

output

{
  "Count": "the count of ruleset, type is number",
  "List": [
    {
      "Name": "the name of ruleset, type is string",
      "AssociatedMatchConfigurations": ["the associated match configuration, type is string"],
      "Description": "the description of ruleset, type is string",
      "CreateTime": "the create time of ruleset, type is string",
      "Type": "the type of ruleset , value: draft | normal, type is string",
      "Script": "the script code of ruleset, type is string"
    }
  ]
}

describe-match-ruleset

cli-load-json

{
  "Name": "required, the name of ruleset, optional, type is string"
}

output

{
  "Name": "the name of ruleset, type is string",
  "AssociatedMatchConfiguration": ["the associated match configuration, type is string"],
  "Description": "the description of ruleset, type is string",
  "CreateTime": "the create time of ruleset, type is string",
  "Type": "the type of ruleset , value: draft | normal, type is string",
  "Script": "the script code of ruleset, type is string"
}

create-match-ruleset

cli-load-json

{
  "Name": "required, the name of ruleset, type is string",
  "Description": "optional, the description of ruleset, type is string",
  "Script": "required, the script of ruleset, type is string"
}

output

{}

update-match-ruleset

cli-load-json

{
  "Name": "required, the name of ruleset, type is string",
  "Description": "optional, the description of ruleset, type is string",
  "Script": "required, the script of ruleset, type is string"
}

output

{}

delete-match-ruleset

cli-load-json

{
  "Name": "required, the name of ruleset, type is string"
}

output

{}

publish-match-ruleset-draft

cli-load-json

{
  "Name": "required, the name of ruleset, type is string",
  "Description": "optional, the description of ruleset, type is string",
  "Script": "required, the script of ruleset, type is string"
}

output

{}

Lobby Interface

list-lobby-config

cli-load-json

{
  "Name": "optional, the name of the battle lobby configuration, type is string",
  "Count": "optional, the count of the battle lobby configuration, type is number",
  "Offset": "optional, the offset of the battle lobby configuration, type is number"
}

output

{
  "Total": "the total count of the battle lobby configuration, type is number",
  "List": [
    {
      "Name": "the name of the battle lobby configuration, must be unique, type is string",
      "PlacerName": "the name of the placer, type is string",
      "Provider": "the provider of the placer, options are `pgos`, `pgos_local_placer`, type is string",
      "PreparingTimeout": "the preparing timeout of the battle lobby configuration, unit is second, type is number",
      "Teams": [
        {
          "Name": "the name of the team, type is string",
          "Capacity": "the capacity of the team, type is number"
        }
      ],
      "StartBattleCondition": "the start battle condition type, options are `All Ready Otherwise Waiting`,`All Ready Otherwise Error`,`Ignoring Ready Flag`, type is string",
      "FlexiblePlacerMapping": [
        {
          "GameMode": "the name of the game mode, type is string",
          "Placer": "the name of the placer, type is string",
          "PlacerProvider": "the provider of the placer, options are `pgos`, `pgos_local_placer`, type is string"
        }
      ],
      "AdvancedMode": "the mode of lobby, options are `ON`, `OFF`, type is string",
      "TeamSelectionStrategy": "the type of `Team Selection Strategy`, options are `Balance Player Count`, `Concentrate Players`, type is string",
      "TeamsGroups": [
        {
          "GroupName": "the name of group, type is string",
          "Teams": [
            {
              "Name": "the name of the team, type is string",
              "Capacity": "the capacity of the team, type is number"
            }
          ],
          "StartBattleCondition": "the start battle condition type for this group, options are `All Ready Otherwise Waiting`,`All Ready Otherwise Error`,`Ignoring Ready Flag`, type is string"
        }
      ],
      "CreatedTime": "the created time of the battle lobby configuration, type is string, use ISO 8601 date format",
      "UpdatedTime": "the updated time of the battle lobby configuration, type is string, use ISO 8601 date format"
    }
  ]
}

describe-lobby-config

cli-load-json

{
  "Name": "required, the name of the battle lobby configuration, type is string"
}

output

{
  "Name": "the name of the battle lobby configuration, must be unique, type is string",
  "PlacerName": "the name of the placer, type is string",
  "Provider": "the provider of the placer, options are `pgos`, `pgos_local_placer`, type is string",
  "PreparingTimeout": "the preparing timeout of the battle lobby configuration, unit is second, type is number",
  "Teams": [
    {
      "Name": "the name of the team, type is string",
      "Capacity": "the capacity of the team, type is number"
    }
  ],
  "StartBattleCondition": "the start battle condition type, options are `All Ready Otherwise Waiting`,`All Ready Otherwise Error`,`Ignoring Ready Flag`, type is string",
  "FlexiblePlacerMapping": [
    {
      "GameMode": "the name of the game mode, type is string",
      "Placer": "the name of the placer, type is string",
      "PlacerProvider": "the provider of the placer, options are `pgos`, `pgos_local_placer`, type is string"
    }
  ],
  "AdvancedMode": "the mode of lobby, options are `ON`, `OFF`, type is string",
  "TeamSelectionStrategy": "the type of `Team Selection Strategy`, options are `Balance Player Count`, `Concentrate Players`, type is string",
  "TeamsGroups": [
    {
      "GroupName": "the name of group, type is string",
      "Teams": [
        {
          "Name": "the name of the team, type is string",
          "Capacity": "the capacity of the team, type is number"
        }
      ],
      "StartBattleCondition": "the start battle condition type for this group, options are `All Ready Otherwise Waiting`,`All Ready Otherwise Error`,`Ignoring Ready Flag`, type is string"
    }
  ],
  "CreatedTime": "the created time of the battle lobby configuration, type is string, use ISO 8601 date format",
  "UpdatedTime": "the updated time of the battle lobby configuration, type is string, use ISO 8601 date format"
}

create-lobby-config

cli-load-json

{
  "Name": "required, the name of the battle lobby configuration, must be unique, type is string",
  "PlacerName": "required, the name of the placer, type is string",
  "Provider": "required, the provider of the placer, options are `pgos`, `pgos_local_placer`, type is string",
  "PreparingTimeout": "required, the preparing timeout of the battle lobby configuration, unit is second, type is number",
  "StartBattleCondition": "required, the start battle condition type, options are `All Ready Otherwise Waiting`,`All Ready Otherwise Error`,`Ignoring Ready Flag`, type is string",
  "Teams": [
    {
      "Name": "required, the name of the team, type is string",
      "Capacity": "required, the capacity of the team, type is number"
    }
  ],
  "FlexiblePlacerMapping": [
    {
      "GameMode": "the name of the game mode, type is string",
      "Placer": "the name of the placer, type is string",
      "PlacerProvider": "the provider of the placer, options are `pgos`, `pgos_local_placer`, type is string"
    }
  ],
  "AdvancedMode": "the mode of lobby, options are `ON`, `OFF`, type is string",
  "TeamSelectionStrategy": "the type of `Team Selection Strategy`, options are `Balance Player Count`, `Concentrate Players`, type is string",
  "TeamsGroups": [
    {
      "GroupName": "the name of group, type is string",
      "Teams": [
        {
          "Name": "the name of the team, type is string",
          "Capacity": "the capacity of the team, type is number"
        }
      ],
      "StartBattleCondition": "the start battle condition type for this group, options are `All Ready Otherwise Waiting`,`All Ready Otherwise Error`,`Ignoring Ready Flag`, type is string"
    }
  ]
}

output

{
  "Name": "the name of the battle lobby configuration, must be unique, type is string",
  "PlacerName": "the name of the placer, type is string",
  "Provider": "the provider of the placer, options are `pgos`, `pgos_local_placer`, type is string",
  "PreparingTimeout": "the preparing timeout of the battle lobby configuration, unit is second, type is number",
  "StartBattleCondition": "the start battle condition type, options are `All Ready Otherwise Waiting`,`All Ready Otherwise Error`,`Ignoring Ready Flag`, type is string",
  "Teams": [
    {
      "Name": "the name of the team, type is string",
      "Capacity": "the capacity of the team, type is number"
    }
  ],
  "FlexiblePlacerMapping": [
    {
      "GameMode": "the name of the game mode, type is string",
      "Placer": "the name of the placer, type is string",
      "PlacerProvider": "the provider of the placer, options are `pgos`, `pgos_local_placer`, type is string"
    }
  ],
  "AdvancedMode": "the mode of lobby, options are `ON`, `OFF`, type is string",
  "TeamSelectionStrategy": "the type of `Team Selection Strategy`, options are `Balance Player Count`, `Concentrate Players`, type is string",
  "TeamsGroups": [
    {
      "GroupName": "the name of group, type is string",
      "Teams": [
        {
          "Name": "the name of the team, type is string",
          "Capacity": "the capacity of the team, type is number"
        }
      ],
      "StartBattleCondition": "the start battle condition type for this group, options are `All Ready Otherwise Waiting`,`All Ready Otherwise Error`,`Ignoring Ready Flag`, type is string"
    }
  ],
  "CreatedTime": "the created time of the battle lobby configuration, type is string, use ISO 8601 date format",
  "UpdatedTime": "the updated time of the battle lobby configuration, type is string, use ISO 8601 date format"
}

delete-lobby-config

cli-load-json

{
  "Name": "required, the name of the battle lobby configuration, type is string"
}

output

{
  "DeletedCount": "the deleted count of the battle lobby configuration, type is number"
}

update-lobby-config

cli-load-json

{
  "Name": "required, the name of the battle lobby configuration, must be unique, type is string",
  "PlacerName": "required, the name of the placer, type is string",
  "Provider": "required, the provider of the placer, options are `pgos`, `pgos_local_placer`, type is string",
  "PreparingTimeout": "required, the preparing timeout of the battle lobby configuration, unit is second, type is number",
  "StartBattleCondition": "required, the start battle condition type, options are `All Ready Otherwise Waiting`,`All Ready Otherwise Error`,`Ignoring Ready Flag`, type is string",
  "Teams": [
    {
      "Name": "required, the name of the team, type is string",
      "Capacity": "required, the capacity of the team, type is number"
    }
  ],
  "FlexiblePlacerMapping": [
    {
      "GameMode": "the name of the game mode, type is string",
      "Placer": "the name of the placer, type is string",
      "PlacerProvider": "the provider of the placer, options are `pgos`, `pgos_local_placer`, type is string"
    }
  ],
  "AdvancedMode": "the mode of lobby, options are `ON`, `OFF`, type is string",
  "TeamSelectionStrategy": "the type of `Team Selection Strategy`, options are `Balance Player Count`, `Concentrate Players`, type is string",
  "TeamsGroups": [
    {
      "GroupName": "the name of group, type is string",
      "Teams": [
        {
          "Name": "the name of the team, type is string",
          "Capacity": "the capacity of the team, type is number"
        }
      ],
      "StartBattleCondition": "the start battle condition type for this group, options are `All Ready Otherwise Waiting`,`All Ready Otherwise Error`,`Ignoring Ready Flag`, type is string"
    }
  ]
}

output

{
  "AffectedCount": "the affected count of the battle lobby configuration, type is number"
}

update-lobby-config-status

cli-load-json

{
  "Name": "required, the name of the battle lobby configuration, type is string",
  "Status": "required, the status of the battle lobby configuration, options are `Enabled`, `Disabled`, type is string"
}

output

{
  "AffectedCount": "the affected count of the battle lobby configuration, type is number"
}

World Filter Interface

create-world-filter

cli-load-json

{
  "Name": "required, the name of the battle world filter, must be unique, type is string",
  "Description": "optional, the description of the battle world filter, type is string",
  "Attributes": [
    {
      "Name": "required, the name of the attribute, type is string",
      "Type": "required, the type of the attribute, options are \"string, number\", type is string",
      "DataSource": "required, the data source of the attribute, options are \"system, clientRequest, playerData\", type is string",
      "Key": "required, the key of the attribute, only support \"playerData\" now, type is string",
      "DefaultValue": "required, the default value of the attribute, type is string",
      "ValueDeclare": ["optional, the value declare of the attribute, type is string"]
    }
  ],
  "Rules": [
    {
      "Name": "required, the name of the rule, type is string",
      "Attribute": "required, the attribute of the rule, type is string",
      "FilterType": "required, the filter type of the rule, options are \"enum\", type is string",
      "UndeclaredDataStrategy": "required, the undeclared data strategy of the rule, options are \"reject, accept\", type is string",
      "EquivalentValues": [["required, the equivalent values of the rule, type is string"]]
    }
  ]
}

output

{
  "Name": "the name of the battle world filter, type is string",
  "Description": "the description of the battle world filter, type is string",
  "Attributes": [
    {
      "Name": "the name of the attribute, type is string",
      "Type": "the type of the attribute, options are \"string, number\", type is string",
      "DataSource": "the data source of the attribute, options are \"system, clientRequest, playerData\", type is string",
      "Key": "the key of the attribute, only support \"playerData\" now, type is string",
      "DefaultValue": "the default value of the attribute, type is string",
      "ValueDeclare": ["the value declare of the attribute, type is string"]
    }
  ],
  "Rules": [
    {
      "Name": "the name of the rule, type is string",
      "Attribute": "the attribute of the rule, type is string",
      "FilterType": "the filter type of the rule, options are \"enum\", type is string",
      "UndeclaredDataStrategy": "the undeclared data strategy of the rule, options are \"reject, accept\", type is string",
      "EquivalentValues": [["the equivalent values of the rule, type is string"]]
    }
  ],
  "CreatedTime": "the created time of the battle world filter, type is string, use ISO 8601 date format",
  "UpdatedTime": "the updated time of the battle world filter, type is string, use ISO 8601 date format"
}

list-world-filter

cli-load-json

{
  "FilterName": "optional, the name of the battle world filter, type is string",
  "Count": "optional, the count of the battle world filter, type is number",
  "Offset": "optional, the offset of the battle world filter, type is number"
}

output

{
  "Total": "the total count of the battle world filter, type is number",
  "List": [
    {
      "Name": "the name of the battle world filter, type is string",
      "Description": "the description of the battle world filter, type is string",
      "Attributes": [
        {
          "Name": "the name of the attribute, type is string",
          "Type": "the type of the attribute, options are \"string, number\", type is string",
          "DataSource": "the data source of the attribute, options are \"system, clientRequest, playerData\", type is string",
          "Key": "the key of the attribute, only support \"playerData\" now, type is string",
          "DefaultValue": "the default value of the attribute, type is string",
          "ValueDeclare": ["the value declare of the attribute, type is string"]
        }
      ],
      "Rules": [
        {
          "Name": "the name of the rule, type is string",
          "Attribute": "the attribute of the rule, type is string",
          "FilterType": "the filter type of the rule, options are \"enum\", type is string",
          "UndeclaredDataStrategy": "the undeclared data strategy of the rule, options are \"reject, accept\", type is string",
          "EquivalentValues": [["the equivalent values of the rule, type is string"]]
        }
      ],
      "CreatedTime": "the created time of the battle world filter, type is string, use ISO 8601 date format",
      "UpdatedTime": "the updated time of the battle world filter, type is string, use ISO 8601 date format"
    }
  ]
}

update-world-filter

cli-load-json

{
  "Name": "required, the name of the battle world filter, must be unique, type is string",
  "Description": "optional, the description of the battle world filter, type is string",
  "Attributes": [
    {
      "Name": "required, the name of the attribute, type is string",
      "Type": "required, the type of the attribute, options are \"string, number\", type is string",
      "DataSource": "required, the data source of the attribute, options are \"system, clientRequest, playerData\", type is string",
      "Key": "required, the key of the attribute, only support \"playerData\" now, type is string",
      "DefaultValue": "required, the default value of the attribute, type is string",
      "ValueDeclare": ["optional, the value declare of the attribute, type is string"]
    }
  ],
  "Rules": [
    {
      "Name": "required, the name of the rule, type is string",
      "Attribute": "required, the attribute of the rule, type is string",
      "FilterType": "required, the filter type of the rule, options are \"enum\", type is string",
      "UndeclaredDataStrategy": "required, the undeclared data strategy of the rule, options are \"reject, accept\", type is string",
      "EquivalentValues": [["required, the equivalent values of the rule, type is string"]]
    }
  ]
}

output

{
  "AffectedCount": "the affected count of the battle world filter, type is number"
}

describe-world-filter

cli-load-json

{
  "FilterName": "required, the name of the battle world filter, type is string"
}

output

{
  "Name": "the name of the battle world filter, type is string",
  "Description": "the description of the battle world filter, type is string",
  "Attributes": [
    {
      "Name": "the name of the attribute, type is string",
      "Type": "the type of the attribute, options are \"string, number\", type is string",
      "DataSource": "the data source of the attribute, options are \"system, clientRequest, playerData\", type is string",
      "Key": "the key of the attribute, only support \"playerData\" now, type is string",
      "DefaultValue": "the default value of the attribute, type is string",
      "ValueDeclare": ["the value declare of the attribute, type is string"]
    }
  ],
  "Rules": [
    {
      "Name": "the name of the rule, type is string",
      "Attribute": "the attribute of the rule, type is string",
      "FilterType": "the filter type of the rule, options are \"enum\", type is string",
      "UndeclaredDataStrategy": "the undeclared data strategy of the rule, options are \"reject, accept\", type is string",
      "EquivalentValues": [["the equivalent values of the rule, type is string"]]
    }
  ],
  "CreatedTime": "the created time of the battle world filter, type is string, use ISO 8601 date format",
  "UpdatedTime": "the updated time of the battle world filter, type is string, use ISO 8601 date format"
}

delete-world-filter

cli-load-json

{
  "FilterName": "required, the name of the battle world filter, type is string"
}

output

{
  "DeletedCount": "the deleted count of the battle world filter, type is number"
}

World Configuration Interface

create-world-config

cli-load-json

{
  "Name": "required, the name of the battle world configuration, must be unique, type is string",
  "Description": "optional, the description of the battle world configuration, type is string",
  "FilterName": "required, the name of the battle world filter, type is string",
  "PlacerName": "required, the name of the placer, type is string",
  "Provider": "required, the provider of the placer, options are \"pgos_placer, pgos_local_placer\", type is string",
  "MaxPlayers": "required, the max players of the battle world configuration, type is number",
  "MaxRunningBucketCount": "required, the max running bucket count of the battle world configuration, type is number",
  "EmptyRecycleSeconds": "required, the empty recycle seconds of the battle world configuration, type is number",
  "BattleProperties": [
    {
      "Key": "the key of the battle property, type is string",
      "Value": "the value of the battle property, type is string"
    }
  ],
  "InvitationTimeoutSeconds": "required, the invitation timeout seconds of the battle world configuration, default is 60, options are 1-600, type is number",
  "JoinRequireDSApproval": "whether join require ds approval, options are \"True, False\", default is False, type is string",
  "MaxBSCountPerBucket": "the max bs count per bucket of the battle world configuration, 0 means no limit, type is number"
}

output

{
  "Name": "the name of the battle world configuration, type is string",
  "Description": "the description of the battle world configuration, type is string",
  "FilterName": "the name of the battle world filter, type is string",
  "PlacerName": "the name of the placer, type is string",
  "Provider": "the provider of the placer, options are \"pgos_placer, pgos_local_placer\", type is string",
  "MaxPlayers": "the max players of the battle world configuration, type is number",
  "MaxRunningBucketCount": "the max running bucket count of the battle world configuration, type is number",
  "EmptyRecycleSeconds": "the empty recycle seconds of the battle world configuration, type is number",
  "BattleProperties": [
    {
      "Key": "the key of the battle property, type is string",
      "Value": "the value of the battle property, type is string"
    }
  ],
  "InvitationTimeoutSeconds": "the invitation timeout seconds of the battle world configuration, default is 60, options are 1-600, type is number",
  "JoinRequireDSApproval": "whether join require ds approval, options are \"True, False\", default is False, type is string",
  "MaxBSCountPerBucket": "the max bs count per bucket of the battle world configuration, 0 means no limit, type is number",
  "CreatedTime": "the created time of the battle world configuration, type is string, use ISO 8601 date format",
  "UpdatedTime": "the updated time of the battle world configuration, type is string, use ISO 8601 date format"
}

list-world-config

cli-load-json

{
  "ConfigurationName": "optional, the name of the battle world configuration, type is string",
  "Count": "optional, the count of the battle world configuration, type is number",
  "Offset": "optional, the offset of the battle world configuration, type is number"
}

output

{
  "Total": "the total count of the battle world configuration, type is number",
  "List": [
    {
      "Name": "the name of the battle world configuration, type is string",
      "Description": "the description of the battle world configuration, type is string",
      "FilterName": "the name of the battle world filter, type is string",
      "PlacerName": "the name of the placer, type is string",
      "Provider": "the provider of the placer, options are \"pgos_placer, pgos_local_placer\", type is string",
      "MaxPlayers": "the max players of the battle world configuration, type is number",
      "MaxRunningBucketCount": "the max running bucket count of the battle world configuration, type is number",
      "EmptyRecycleSeconds": "the empty recycle seconds of the battle world configuration, type is number",
      "BattleProperties": [
        {
          "Key": "the key of the battle property, type is string",
          "Value": "the value of the battle property, type is string"
        }
      ],
      "InvitationTimeoutSeconds": "the invitation timeout seconds of the battle world configuration, default is 60, options are 1-600, type is number",
      "JoinRequireDSApproval": "whether join require ds approval, options are \"True, False\", default is False, type is string",
      "MaxBSCountPerBucket": "the max bs count per bucket of the battle world configuration, 0 means no limit, type is number",
      "CreatedTime": "the created time of the battle world configuration, type is string, use ISO 8601 date format",
      "UpdatedTime": "the updated time of the battle world configuration, type is string, use ISO 8601 date format"
    }
  ]
}

update-world-config

cli-load-json

{
  "Name": "required, the name of the battle world configuration, must be unique, type is string",
  "Description": "optional, the description of the battle world configuration, type is string",
  "FilterName": "required, the name of the battle world filter, type is string",
  "PlacerName": "required, the name of the placer, type is string",
  "Provider": "required, the provider of the placer, options are \"pgos_placer, pgos_local_placer\", type is string",
  "MaxPlayers": "required, the max players of the battle world configuration, type is number",
  "MaxRunningBucketCount": "required, the max running bucket count of the battle world configuration, type is number",
  "EmptyRecycleSeconds": "required, the empty recycle seconds of the battle world configuration, type is number",
  "BattleProperties": [
    {
      "Key": "the key of the battle property, type is string",
      "Value": "the value of the battle property, type is string"
    }
  ],
  "InvitationTimeoutSeconds": "required, the invitation timeout seconds of the battle world configuration, default is 60, options are 1-600, type is number",
  "JoinRequireDSApproval": "whether join require ds approval, options are \"True, False\", default is False, type is string",
  "MaxBSCountPerBucket": "the max bs count per bucket of the battle world configuration, 0 means no limit, type is number"
}

output

{
  "AffectedCount": "the affected count of the battle world configuration, type is number"
}

describe-world-config

cli-load-json

{
  "ConfigurationName": "required, the name of the battle world configuration, type is string"
}

output

{
  "Name": "the name of the battle world configuration, type is string",
  "Description": "the description of the battle world configuration, type is string",
  "FilterName": "the name of the battle world filter, type is string",
  "PlacerName": "the name of the placer, type is string",
  "Provider": "the provider of the placer, options are \"pgos_placer, pgos_local_placer\", type is string",
  "MaxPlayers": "the max players of the battle world configuration, type is number",
  "MaxRunningBucketCount": "the max running bucket count of the battle world configuration, type is number",
  "EmptyRecycleSeconds": "the empty recycle seconds of the battle world configuration, type is number",
  "BattleProperties": [
    {
      "Key": "the key of the battle property, type is string",
      "Value": "the value of the battle property, type is string"
    }
  ],
  "InvitationTimeoutSeconds": "the invitation timeout seconds of the battle world configuration, default is 60, options are 1-600, type is number",
  "JoinRequireDSApproval": "whether join require ds approval, options are \"True, False\", default is False, type is string",
  "MaxBSCountPerBucket": "the max bs count per bucket of the battle world configuration, 0 means no limit, type is number",
  "CreatedTime": "the created time of the battle world configuration, type is string, use ISO 8601 date format",
  "UpdatedTime": "the updated time of the battle world configuration, type is string, use ISO 8601 date format"
}

delete-world-config

cli-load-json

{
  "ConfigurationName": "required, the name of the battle world configuration, type is string"
}

output

{
  "DeletedCount": "the deleted count of the battle world configuration, type is number"
}

Battle Session Interface

list-battle-session

cli-load-json

{
  "Status": "optional, the status of the battle session, options are: Pending, Cancelled, Timeout, Failed, Activating, Active, Terminated, type is string",
  "FleetID": "optional, the id of the fleet, type is string",
  "BattleSessionID": "optional, the id of the battle session, type is string",
  "SourceType": "optional, the type of the source configuration, options are: MatchConfiguration, LobbyConfiguration, WorldConfiguration, Standalone, type is string",
  "ConfigurationName": "optional, the name of the configuration, type is string",
  "CVMInstanceID": "optional, the id of the cvm instance, type is string",
  "BuildID": "optional, the id of the build, type is string",
  "DataCenter": "optional, the data center, type is string",
  "Count": "required, the maximum number of results to return, type is number",
  "Offset": "required, the start of the next sequential page of results, type is number"
}

output

[
  {
    "BattleSessionID": "the id of the battle session, type is string",
    "BuildID": "the id of the build, type is string",
    "FleetID": "the id of the fleet, type is string",
    "CVMInstanceID": "the id of the cvm instance, type is string",
    "DSInstanceID": "the id of the ds instance, type is string",
    "Status": "the status of the battle session, options are: Pending, Cancelled, Timeout, Failed, Activating, Active, Terminated, type is string",
    "StatusReason": "the reason of the status, type is string",
    "SourceType": "the type of the source configuration, options are: MatchConfiguration, LobbyConfiguration, WorldConfiguration, Standalone, type is string",
    "ConfigurationName": "the name of the configuration, type is string",
    "IsLocalDS": "whether the ds is local, type is boolean",
    "Provider": "the provider of the cloud, type is string",
    "DataCenter": "the data center, type is string",
    "PlacerName": "the placer name, type is string",
    "IPAddress": "the ip address, type is string",
    "Port": "the port, type is number",
    "PlayerIDs": ["the list of player ids, type is string"],
    "PlayerLatencies": [
      {
        "PlayerID": "the id of the player, type is string",
        "Provider": "the provider of the cloud, type is string",
        "Zone": "the zone, type is string",
        "DataCenter": "the data center, type is string",
        "LatencyInMilliseconds": "the latency in milliseconds, type is number",
        "IsLatencyEstimated": "whether the latency is estimated, type is boolean"
      }
    ],
    "MaxPlayerCount": "the maximum player count, type is number",
    "CurrentPlayerCount": "the current player count, type is number",
    "CreatedTime": "the created time, use ISO 8601 date format, type is string",
    "TerminatedTime": "the terminated time, use ISO 8601 date format, type is string"
  }
]

✨️ Request Example

{
  "Status": "",
  "FleetID": "4c55bd78-d6d7-47c0-b930-9a174ce4c4dc",
  "BattleSessionID": "",
  "SourceType": "MatchConfiguration",
  "ConfigurationName": "battle-5v5-demo",
  "CVMInstanceID": "",
  "BuildID": "53273800253554",
  "DataCenter": "ap-guangzhou",
  "Count": 10,
  "Offset": 0
}

describe-battle-session

cli-load-json

{
  "BattleSessionID": "required, the id of the battle session, type is string"
}

output

{
  "BattleSession": {
    "BattleSessionID": "the id of the battle session, type is string",
    "BuildID": "the id of the build, type is string",
    "FleetID": "the id of the fleet, type is string",
    "CVMInstanceID": "the id of the cvm instance, type is string",
    "DSInstanceID": "the id of the ds instance, type is string",
    "Status": "the status of the battle session, options are: Pending, Cancelled, Timeout, Failed, Activating, Active, Terminated, type is string",
    "StatusReason": "the reason of the status, type is string",
    "SourceType": "the type of the source configuration, options are: MatchConfiguration, LobbyConfiguration, WorldConfiguration, Standalone, type is string",
    "ConfigurationName": "the name of the configuration, type is string",
    "IsLocalDS": "whether the ds is local, type is boolean",
    "Provider": "the provider of the cloud, type is string",
    "DataCenter": "the data center, type is string",
    "PlacerName": "the placer name, type is string",
    "IPAddress": "the ip address, type is string",
    "Port": "the port, type is number",
    "PlayerIDs": ["the list of player ids, type is string"],
    "PlayerLatencies": [
      {
        "PlayerID": "the id of the player, type is string",
        "Provider": "the provider of the cloud, type is string",
        "Zone": "the zone, type is string",
        "DataCenter": "the data center, type is string",
        "LatencyInMilliseconds": "the latency in milliseconds, type is number",
        "IsLatencyEstimated": "whether the latency is estimated, type is boolean"
      }
    ],
    "MaxPlayerCount": "the maximum player count, type is number",
    "CurrentPlayerCount": "the current player count, type is number",
    "CreatedTime": "the created time, use ISO 8601 date format, type is string",
    "TerminatedTime": "the terminated time, use ISO 8601 date format, type is string"
  },
  "BackfillLog": [
    {
      "BattleSessionID": "the id of the battle session, type is string",
      "EventTime": "the time of the event, use ISO 8601 date format, type is string",
      "Status": "the status of the event, type is string",
      "Reason": "the reason of the event, type is string"
    }
  ],
  "BattleData": [
    {
      "CreatedTime": "the time the battle data was created, use ISO 8601 date format, type is string",
      "UpdatedTime": "the time the battle data was updated, use ISO 8601 date format, type is string",
      "Tags": ["the tags of the battle data, type is string"],
      "Data": "the data of the battle data, type is object"
    }
  ],
  "StandaloneLog": [
    {
      "EventTime": "the time of the event, use ISO 8601 date format, type is string",
      "PlayerBattleSessionID": "the id of the player battle session, type is string",
      "PlayerID": "the id of the player, type is string",
      "Team": "the team of the player, type is string",
      "IPAddress": "the ip address of the player, type is string",
      "Longtitude": "the longtitude of the player, type is string",
      "Latitude": "the latitude of the player, type is string",
      "PlayerAttributes": [
        {
          "Key": "the key of the player attribute, type is string",
          "Type": "the type of the player attribute, type is string",
          "Value": "the value of the player attribute, type is string"
        }
      ]
    }
  ]
}

✨️ Request Example

{
  "BattleSessionID": "f8c34a53-e1b9-4a6a-8ef6-6104d24608ed"
}

list-battle-session-log-file

提示

Occording to the status of the battle session, the log file can be obtained in two ways:

• If the status of the battle session is Terminated, the log file can be obtained directly, and the field returned is BattleSessionLogDestination.
• If the status of the battle session is Active, the log file can be obtained from the server, and the field returned is BattleSessionLogDirectory. If you need to download the log file, you need to use the collect-fleet-cvm-instance-file command.

cli-load-json

{
  "BattleSessionID": "required, the id of the battle session, type is string"
}

output

{
  "BattleSessionStatus": "the status of the battle session, options are: Pending, Cancelled, Timeout, Failed, Activating, Active, Terminated, type is string",
  "BattleSessionFleetID": "the id of the fleet, type is string",
  "BattleSessionCVMInstanceID": "the id of the cvm instance, type is string",
  "BattleSessionPlacer": "the placer of the battle session, type is string",
  "BattleSessionLogDestination": {
    "CloudFileDownloadURL": "the download url of file, type is string",
    "CloudFileDestination": {
      "Provider": "the provider of the cloud file destination, type is string",
      "DataCenter": "the data center of the cloud file destination, type is string",
      "Bucket": "the bucket of the cloud file destination, type is string",
      "BucketKey": "the bucket key of the cloud file destination, type is string"
    }
  },
  "BattleSessionLogDirectory": [
    {
      "FilePath": "the file path of the log directory, type is string",
      "ModifiedTime": "the time the file was modified, use ISO 8601 date format, type is string",
      "Size": "the size of the file, type is number",
      "SizeMB": "the size of the file in MB, type is number"
    }
  ]
}

✨️ Request Example

{
  "BattleSessionID": "f8c34a53-e1b9-4a6a-8ef6-6104d24608ed"
}

list-player-battle-session

cli-load-json

{
  "BattleSessionID": "required, the id of the battle session, type is string",
  "Count": "required, the maximum number of results to return, type is number",
  "Offset": "required, the start of the next sequential page of results, type is number"
}

output

[
  {
    "PlayerBattleSessionID": "the id of the player battle session, type is string",
    "PlayerID": "the id of the player, type is string",
    "Status": "the status of the player battle session, type is string",
    "EventTime": "the time of the event, use ISO 8601 date format, type is string",
    "FirstConnectedTime": "the time the player first connected, use ISO 8601 date format, type is string",
    "TerminatedTime": "the time the player was terminated, use ISO 8601 date format, type is string"
  }
]

✨️ Request Example

{
  "BattleSessionID": "f8c34a53-e1b9-4a6a-8ef6-6104d24608ed",
  "Count": 100,
  "Offset": 0
}

Virtual Server Interface

create-virtual-server

cli-load-json

{
  "ServerName": "required, the name of the virtual server, must be unique, type is string",
  "Description": "optional, the description of the virtual server, type is string",
  "ResourceType": "required, the resource type of the virtual server, must be \"SourceCode\" or \"DockerImage\", type is string",
  "ResourceMethod": "required, the resource method of the virtual server, must be \"LocalFileUpload\" or \"ImageResourceUrl\", type is string",
  "ResourceFileMD5": "required, the resource file md5 of the virtual server, must be \"LocalFileUpload\" in virtual server request, type is string",
  "ResourceImageVersion": "required, the resource image version of the virtual server, must be \"ImageResourceUrl\" in virtual server request, type is string",
  "ResourceImagePath": "required, the resource image path of the virtual server, must be \"ImageResourceUrl\" in virtual server request, type is string",
  "ResourceLimitation": {
    "CpuMaxLimitation": "required, the cpu max limitation of the virtual server, must be \"0.25\" or \"0.5\" or \"1\" or \"2\" or \"4\" or \"8\" or \"16\", type is string",
    "MemoryMaxLimitation": "required, the memory max limitation of the virtual server, must be \"256MiB\" or \"512MiB\" or \"1GiB\" or \"2GiB\" or \"4GiB\" or \"8GiB\", type is string"
  },
  "MaxInstances": "required, the max instances of the virtual server, type is number, must be greater than 0",
  "MaxInstanceStrategy": "required, the max instance strategy of the virtual server, must be \"Auto\" or \"Manual\", type is string",
  "ListenPort": "required, the listen port of the virtual server, type is number, must be greater than 0",
  "EnvVars": [
    {
      "Key": "the key of the env var, type is string",
      "Value": "the value of the env var, type is string"
    }
  ],
  "IsBlockClientReq": "required, the is block client req of the virtual server, type is string, must be \"TRUE\" or \"FALSE\"",
  "LaunchArgs": ["the launch args of the virtual server, type is string"]
}

cli-upload-files

[
  {
    "path": "the path of the file to upload, type is string",
    "label": "the label of the file to upload, must be \"ResourceFileBucketKey\" in virtual server request, type is string"
  }
]

output

{
  "ID": "the id of the virtual server, type is string",
  "ServerName": "the name of the virtual server, type is string"
}

list-virtual-server

cli-load-json

{
  "ServerName": "optional, the name of the virtual server, type is string",
  "Count": "optional, the count of the virtual server, type is number",
  "Offset": "optional, the offset of the virtual server, type is number"
}

output

[
  {
    "ID": "the id of the virtual server, type is number",
    "ServerName": "the name of the virtual server, type is string",
    "Status": "the status of the virtual server, type is string",
    "DeployStatus": "the deploy status of the virtual server, type is string",
    "DeployMessage": "the deploy message of the virtual server, type is string",
    "IsEnabled": "the is enabled of the virtual server, type is string, must be \"TRUE\" or \"FALSE\"",
    "Description": "the description of the virtual server, type is string",
    "ResourceType": "the resource type of the virtual server, must be \"SourceCode\" or \"DockerImage\", type is string",
    "ResourceMethod": "the resource method of the virtual server, must be \"LocalFileUpload\" or \"ImageResourceUrl\", type is string",
    "ResourceFileMD5": "the resource file md5 of the virtual server, must be \"LocalFileUpload\" in virtual server request, type is string",
    "ResourceImageVersion": "the resource image version of the virtual server, must be \"ImageResourceUrl\" in virtual server request, type is string",
    "ResourceImagePath": "the resource image path of the virtual server, must be \"ImageResourceUrl\" in virtual server request, type is string",
    "ResourceFileBucketKey": "the resource file bucket key of the virtual server, must be \"LocalFileUpload\" in virtual server request, type is string",
    "ResourceLimitation": {
      "CpuMaxLimitation": "the cpu max limitation of the virtual server, must be \"0.25\" or \"0.5\" or \"1\" or \"2\" or \"4\" or \"8\" or \"16\" or \"32\", type is string",
      "MemoryMaxLimitation": "the memory max limitation of the virtual server, must be \"256MiB\" or \"512MiB\" or \"1GiB\" or \"2GiB\" or \"4GiB\" or \"8GiB\", type is string"
    },
    "MaxInstances": "the max instances of the virtual server, type is number, must be greater than 0",
    "MaxInstanceStrategy": "the max instance strategy of the virtual server, must be \"Auto\" or \"Manual\", type is string",
    "ListenPort": "the listen port of the virtual server, type is number, must be greater than 0",
    "EnvVars": [
      {
        "Key": "the key of the env var, type is string",
        "Value": "the value of the env var, type is string"
      }
    ],
    "IsBlockClientReq": "the is block client req of the virtual server, type is string, must be \"TRUE\" or \"FALSE\"",
    "CreatedTime": "the created time of the virtual server, type is string, use ISO 8601 date format",
    "UpdatedTime": "the updated time of the virtual server, type is string, use ISO 8601 date format",
    "ActiveInstances": "the active instances of the virtual server, type is number",
    "LaunchArgs": ["the launch args of the virtual server, type is string"]
  }
]

update-virtual-server

cli-load-json

{
  "ServerName": "required, the name of the virtual server, must be unique, type is string",
  "Description": "optional, the description of the virtual server, type is string",
  "ResourceType": "required, the resource type of the virtual server, must be \"SourceCode\" or \"DockerImage\", type is string",
  "ResourceMethod": "required, the resource method of the virtual server, must be \"LocalFileUpload\" or \"ImageResourceUrl\", type is string",
  "ResourceFileMD5": "required, the resource file md5 of the virtual server, must be \"LocalFileUpload\" in virtual server request, type is string",
  "ResourceImageVersion": "required, the resource image version of the virtual server, must be \"ImageResourceUrl\" in virtual server request, type is string",
  "ResourceImagePath": "required, the resource image path of the virtual server, must be \"ImageResourceUrl\" in virtual server request, type is string",
  "ResourceLimitation": {
    "CpuMaxLimitation": "required, the cpu max limitation of the virtual server, must be \"0.25\" or \"0.5\" or \"1\" or \"2\" or \"4\" or \"8\" or \"16\" or \"32\", type is string",
    "MemoryMaxLimitation": "required, the memory max limitation of the virtual server, must be \"256MiB\" or \"512MiB\" or \"1GiB\" or \"2GiB\" or \"4GiB\" or \"8GiB\", type is string"
  },
  "MaxInstances": "required, the max instances of the virtual server, type is number, must be greater than 0",
  "MaxInstanceStrategy": "required, the max instance strategy of the virtual server, must be \"Auto\" or \"Manual\", type is string",
  "ListenPort": "required, the listen port of the virtual server, type is number, must be greater than 0",
  "EnvVars": [
    {
      "Key": "the key of the env var, type is string",
      "Value": "the value of the env var, type is string"
    }
  ],
  "IsBlockClientReq": "required, the is block client req of the virtual server, type is string, must be \"TRUE\" or \"FALSE\"",
  "LaunchArgs": ["the launch args of the virtual server, type is string"]
}

cli-upload-files

[
  {
    "path": "the path of the file to upload, type is string",
    "label": "the label of the file to upload, must be \"ResourceFileBucketKey\" in virtual server request, type is string"
  }
]

output

{}

describe-virtual-server

cli-load-json

{
  "ServerName": "required, the name of the virtual server, type is string"
}

output

{
  "ID": "the id of the virtual server, type is number",
  "ServerName": "the name of the virtual server, type is string",
  "Status": "the status of the virtual server, type is string",
  "DeployStatus": "the deploy status of the virtual server, type is string",
  "DeployMessage": "the deploy message of the virtual server, type is string",
  "IsEnabled": "the is enabled of the virtual server, type is string, must be \"TRUE\" or \"FALSE\"",
  "Description": "the description of the virtual server, type is string",
  "ResourceType": "the resource type of the virtual server, must be \"SourceCode\" or \"DockerImage\", type is string",
  "ResourceMethod": "the resource method of the virtual server, must be \"LocalFileUpload\" or \"ImageResourceUrl\", type is string",
  "ResourceFileMD5": "the resource file md5 of the virtual server, must be \"LocalFileUpload\" in virtual server request, type is string",
  "ResourceImageVersion": "the resource image version of the virtual server, must be \"ImageResourceUrl\" in virtual server request, type is string",
  "ResourceImagePath": "the resource image path of the virtual server, must be \"ImageResourceUrl\" in virtual server request, type is string",
  "ResourceFileBucketKey": "the resource file bucket key of the virtual server, must be \"LocalFileUpload\" in virtual server request, type is string",
  "ResourceLimitation": {
    "CpuMaxLimitation": "the cpu max limitation of the virtual server, must be \"0.25\" or \"0.5\" or \"1\" or \"2\" or \"4\" or \"8\" or \"16\" or \"32\", type is string",
    "MemoryMaxLimitation": "the memory max limitation of the virtual server, must be \"256MiB\" or \"512MiB\" or \"1GiB\" or \"2GiB\" or \"4GiB\" or \"8GiB\", type is string"
  },
  "MaxInstances": "the max instances of the virtual server, type is number, must be greater than 0",
  "MaxInstanceStrategy": "the max instance strategy of the virtual server, must be \"Auto\" or \"Manual\", type is string",
  "ListenPort": "the listen port of the virtual server, type is number, must be greater than 0",
  "EnvVars": [
    {
      "Key": "the key of the env var, type is string",
      "Value": "the value of the env var, type is string"
    }
  ],
  "IsBlockClientReq": "the is block client req of the virtual server, type is string, must be \"TRUE\" or \"FALSE\"",
  "CreatedTime": "the created time of the virtual server, type is string, use ISO 8601 date format",
  "UpdatedTime": "the updated time of the virtual server, type is string, use ISO 8601 date format",
  "ActiveInstances": "the active instances of the virtual server, type is number",
  "LaunchArgs": ["the launch args of the virtual server, type is string"]
}

delete-virtual-server

cli-load-json

{
  "ServerName": "required, the name of the virtual server, type is string"
}

output

{}

describe-virtual-server-env-vars

cli-load-json

{
  "ServerName": "required, the name of the virtual server, type is string"
}

output

[
  {
    "Key": "the key of the env var, type is string",
    "Value": "the value of the env var, type is string"
  }
]

update-virtual-server-env-vars

cli-load-json

{
  "ServerName": "required, the name of the virtual server, type is string",
  "EnvVars": [
    {
      "Key": "the key of the env var, type is string",
      "Value": "the value of the env var, type is string"
    }
  ]
}

output

{}

collect-virtual-server-logs

cli-load-json

{
  "ServerName": "required, the name of the virtual server, type is string",
  "Type": "required, the type of the virtual server logs, must be \"RuntimeLog\" or \"AccessLog\", type is string",
  "Count": "required, the count of the virtual server logs, type is number, must be greater than 0, max number is 1000,000, default is 1000, type is number",
  "FromTime": "required, the start time of the virtual server logs, type is string, use ISO 8601 date format",
  "ToTime": "required, the end time of the virtual server logs, type is string, use ISO 8601 date format",
  "SearchKey": "optional, the search value of the virtual server logs, type is string",
  "OrderBy": "optional, the order by of the virtual server logs, must be \"asc\" or \"desc\", default is \"asc\", type is string",
  "Format": "optional, the format of the virtual server logs, must be \"json\" or \"csv\", default is \"json\", type is string"
}

output

{
  "CollectID": "the log collection id of the virtual server logs, type is string"
}

✨️ Request Example

{
  "ServerName": "will-test-vs-xxx",
  "Type": "RuntimeLog",
  "Count": 10000,
  "FromTime": "2024-11-05T00:00:00Z",
  "ToTime": "2024-11-08T00:00:00Z",
  "SearchKey": "request",
  "OrderBy": "asc",
  "Format": "json"
}

delete-virtual-server-log-collection

cli-load-json

{
  "ServerName": "the name of the virtual server, type is string",
  "Type": "the type of the virtual server logs, must be \"RuntimeLog\" or \"AccessLog\", type is string",
  "CollectID": "the log collection id of the virtual server logs, type is string"
}

output

{}

✨️ Request Example

{
  "ServerName": "will-test-vs-xxx",
  "Type": "RuntimeLog",
  "CollectID": "export-4a1d4355-d91d-4414-8d90-bfaf2ec28fce"
}

list-virtual-server-log-collection

cli-load-json

{
  "ServerName": "the name of the virtual server, type is string",
  "Type": "the type of the virtual server logs, must be \"RuntimeLog\" or \"AccessLog\", type is string"
}

output

[
  {
    "CollectID": "the log collection id of the virtual server logs, type is string",
    "FileName": "the file name of the virtual server logs, type is string",
    "FilePath": "the file path of the virtual server logs, only when the status is \"Completed\", you can download the file, type is string",
    "FileSize": "the file size of the virtual server logs, type is string",
    "Status": "the status of the virtual server collection, must be \"Processing\" or \"Completed\" or \"Failed\" or \"Expired\" or \"Queuing\", type is string"
  }
]

✨️ Request Example

{
  "ServerName": "will-test-vs-20241015",
  "Type": "RuntimeLog"
}

describe-virtual-server-log-collection

cli-load-json

{
  "ServerName": "the name of the virtual server, type is string",
  "Type": "the type of the virtual server logs, must be \"RuntimeLog\" or \"AccessLog\", type is string",
  "CollectID": "the log collection id of the virtual server logs, type is string"
}

output

{
  "CollectID": "the log collection id of the virtual server logs, type is string",
  "FileName": "the file name of the virtual server logs, type is string",
  "FilePath": "the file path of the virtual server logs, only when the status is \"Completed\", you can download the file, type is string",
  "FileSize": "the file size of the virtual server logs, type is string",
  "Status": "the status of the virtual server collection, must be \"Processing\" or \"Completed\" or \"Failed\" or \"Expired\" or \"Queuing\", type is string"
}

✨️ Request Example

{
  "ServerName": "will-test-vs-xxx",
  "Type": "RuntimeLog",
  "CollectID": "export-8961ccf1-5ac2-4501-9003-58bd63ef8ab1"
}

Economy Virtual Currency Interface

list-virtual-currency

cli-load-json

{
  "CurrencyType": "the type of the economy currency, options are: VirtualCurrency, MidasGlobalToken, type is string"
}

output

[
  {
    "CurrencyType": "the type of the economy currency, type is string",
    "CurrencyCode": "the code of the economy currency, type is string",
    "CurrencyName": "the name of the economy currency, type is string",
    "CurrencyIcon": "the icon of the economy currency, type is string",
    "InitialDeposit": "the initial deposit of the economy currency, only support VirtualCurrency now, type is number, must be greater than 0",
    "MaxDeposit": "the max deposit of the economy currency, only support VirtualCurrency now, 0 means no limit, max number is 4,294,967,295 (uint32 max value), type is number",
    "ResourceID": "the resource id of the economy currency, only support MidasGlobalToken now, type is string"
  }
]

✨️ Request Example

{
  "CurrencyType": "MidasGlobalToken"
}

describe-virtual-currency

cli-load-json

{
  "CurrencyCode": "required, the code of the economy currency, type is string"
}

output

{
  "CurrencyCode": "the code of the economy currency, type is string",
  "CurrencyName": "the name of the economy currency, type is string",
  "CurrencyIcon": "the icon of the economy currency, type is string",
  "InitialDeposit": "the initial deposit of the economy currency, only support VirtualCurrency now, type is number, must be greater than 0",
  "MaxDeposit": "the max deposit of the economy currency, only support VirtualCurrency now, 0 means no limit, max number is 4,294,967,295 (uint32 max value), type is number",
  "ResourceID": "the resource id of the economy currency, only support MidasGlobalToken now, type is string",
  "CreatedTime": "the created time of the virtual server, type is string, use ISO 8601 date format",
  "UpdatedTime": "the updated time of the virtual server, type is string, use ISO 8601 date format"
}

✨️ Request Example

{
  "CurrencyCode": "BTC"
}

create-virtual-currency

cli-load-json

{
  "CurrencyType": "the type of the economy currency, options are: VirtualCurrency, MidasGlobalToken, type is string",
  "CurrencyCode": "the code of the economy currency, type is string",
  "CurrencyName": "the name of the economy currency, type is string",
  "CurrencyIcon": "the icon of the economy currency, type is string",
  "InitialDeposit": "the initial deposit of the economy currency, only support VirtualCurrency now, type is number, must be greater than 0",
  "MaxDeposit": "the max deposit of the economy currency, only support VirtualCurrency now, 0 means no limit, max number is 4,294,967,295 (uint32 max value), type is number",
  "ResourceID": "the resource id of the economy currency, only support MidasGlobalToken now, type is string"
}

output

{}

✨️ Request Example

{
  "CurrencyType": "MidasGlobalToken",
  "CurrencyCode": "MIDASGLOBALCOIN",
  "CurrencyName": "xxxxx",
  "CurrencyIcon": "xxx.png",
  "InitialDeposit": 0,
  "MaxDeposit": 0,
  "ResourceID": "xxxxx"
}

update-virtual-currency

cli-load-json

{
  "CurrencyType": "the type of the economy currency, options are: VirtualCurrency, MidasGlobalToken, type is string",
  "CurrencyCode": "the code of the economy currency, type is string",
  "CurrencyName": "the name of the economy currency, type is string",
  "CurrencyIcon": "the icon of the economy currency, type is string",
  "InitialDeposit": "the initial deposit of the economy currency, only support VirtualCurrency now, type is number, must be greater than 0",
  "MaxDeposit": "the max deposit of the economy currency, only support VirtualCurrency now, 0 means no limit, max number is 4,294,967,295 (uint32 max value), type is number",
  "ResourceID": "the resource id of the economy currency, only support MidasGlobalToken now, type is string"
}

output

{}

✨️ Request Example

{
  "CurrencyType": "VirtualCurrency",
  "CurrencyCode": "MIDASGLOBALCOIN",
  "CurrencyName": "111",
  "CurrencyIcon": "111.png",
  "InitialDeposit": 0,
  "MaxDeposit": 0,
  "ResourceID": "xxxxx"
}

delete-virtual-currency

cli-load-json

{
  "CurrencyCode": "required, the code of the economy currency, type is string"
}

output

{}

✨️ Request Example

{
  "CurrencyCode": "BTC"
}

export-virtual-currency

cli-load-json

{}

output

[
  {
    "CurrencyType": "the type of the economy currency, options are: VirtualCurrency, MidasGlobalToken, type is string",
    "CurrencyCode": "the code of the economy currency, type is string",
    "CurrencyName": "the name of the economy currency, type is string",
    "CurrencyIcon": "the icon of the economy currency, type is string",
    "InitialDeposit": "the initial deposit of the economy currency, only support VirtualCurrency now, type is number, must be greater than 0",
    "MaxDeposit": "the max deposit of the economy currency, only support VirtualCurrency now, 0 means no limit, max number is 4,294,967,295 (uint32 max value), type is number",
    "ResourceID": "the resource id of the economy currency, only support MidasGlobalToken now, type is string"
  }
]

✨️ Request Example

{}

check-virtual-currency

cli-load-json

{
  "Content": [
    {
      "CurrencyType": "the type of the economy currency, options are: VirtualCurrency, MidasGlobalToken, type is string",
      "CurrencyCode": "the code of the economy currency, type is string",
      "CurrencyName": "the name of the economy currency, type is string",
      "CurrencyIcon": "the icon of the economy currency, type is string",
      "InitialDeposit": "the initial deposit of the economy currency, only support VirtualCurrency now, type is number, must be greater than 0",
      "MaxDeposit": "the max deposit of the economy currency, only support VirtualCurrency now, 0 means no limit, max number is 4,294,967,295 (uint32 max value), type is number",
      "ResourceID": "the resource id of the economy currency, only support MidasGlobalToken now, type is string"
    }
  ]
}

output

{
  "FailedItems": [
    {
      "Key": "the key of the failed item, type is string",
      "Reason": "the reason of the failed item, type is string"
    }
  ]
}

✨️ Request Example

{
  "Content": [
    {
      "CurrencyType": "VirtualCurrency",
      "CurrencyCode": "CURRENCYCODEAA",
      "CurrencyName": "CurrencyCode",
      "CurrencyIcon": "xxx.png",
      "InitialDeposit": 1000,
      "MaxDeposit": 0,
      "ResourceID": "xxxxx"
    }
  ]
}

import-virtual-currency

提示

When you need to perform an import operation, it is recommended to use the check-virtual-currency command to check whether the imported data meets the requirements. Select the appropriate Mode strategy when performing the import.

cli-load-json

{
  "Mode": "the mode of the import virtual currency, options are \"Merge\" or \"Override\", type is string",
  "Content": [
    {
      "CurrencyType": "the type of the economy currency, options are: VirtualCurrency, MidasGlobalToken, type is string",
      "CurrencyCode": "the code of the economy currency, type is string",
      "CurrencyName": "the name of the economy currency, type is string",
      "CurrencyIcon": "the icon of the economy currency, type is string",
      "InitialDeposit": "the initial deposit of the economy currency, only support VirtualCurrency now, type is number, must be greater than 0",
      "MaxDeposit": "the max deposit of the economy currency, only support VirtualCurrency now, 0 means no limit, max number is 4,294,967,295 (uint32 max value), type is number",
      "ResourceID": "the resource id of the economy currency, only support MidasGlobalToken now, type is string"
    }
  ]
}

output

{
  "AddedItems": ["the successfully added economy currencies, type is string"],
  "UpdatedItems": ["the successfully updated economy currencies, type is string"],
  "DeletedItems": ["the successfully deleted economy currencies, type is string"],
  "FailedItems": [
    {
      "Key": "the key of the failed item, type is string",
      "Reason": "the reason of the failed item, type is string"
    }
  ]
}

✨️ Request Example

{
  "Mode": "Merge",
  "Content": [
    {
      "CurrencyType": "VirtualCurrency",
      "CurrencyCode": "LTC",
      "CurrencyName": "LTC",
      "CurrencyIcon": "LTC.png",
      "InitialDeposit": 10000,
      "MaxDeposit": 0,
      "ResourceID": "xxxxx"
    },
    {
      "CurrencyType": "VirtualCurrency",
      "CurrencyCode": "BTC",
      "CurrencyName": "BTC",
      "CurrencyIcon": "BTC.png",
      "InitialDeposit": 10000,
      "MaxDeposit": 0,
      "ResourceID": "xxxxx"
    },
    {
      "CurrencyType": "VirtualCurrency",
      "CurrencyCode": "EOS",
      "CurrencyName": "EOS",
      "CurrencyIcon": "EOS.png",
      "InitialDeposit": 10000,
      "MaxDeposit": 0,
      "ResourceID": "xxxxx"
    }
  ]
}

Economy Ingame Item Interface

list-ingame-item

cli-load-json

{
  "ItemType": "required, the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
  "SearchKey": "optional, the search key of the economy ingame item id or name, type is string"
}

output

[
  {
    "ItemId": "the id of the economy ingame item, type is string",
    "ItemType": "the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
    "DisplayName": "the display name of the economy ingame item, type is string",
    "Icon": "the icon of the economy ingame item, type is string",
    "Description": "the description of the economy ingame item, type is string",
    "DefaultPrices": [
      {
        "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
        "CurrencyCode": "the currency code of the economy ingame item, type is string",
        "CurrencyName": "the currency name of the economy ingame item, type is string",
        "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
      }
    ],
    "ItemContent": [
      {
        "ItemId": "the id of the economy ingame item, type is string",
        "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
      }
    ],
    "VirtualCurrencyContent": [
      {
        "CurrencyCode": "the currency code of the economy ingame item, type is string",
        "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
        "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
      }
    ],
    "ValidDuration": "the valid duration of the economy ingame item, type is number, must be greater than 0, unit is second",
    "IsUnique": "the is unique of the economy ingame item, type is boolean, only support NormalItem",
    "IsStackable": "the is stackable of the economy ingame item, type is boolean, only support NormalItem",
    "IsTradable": "the is tradable of the economy ingame item, type is boolean, only support NormalItem",
    "IsConsumable": "the is consumable of the economy ingame item, type is boolean, only support NormalItem",
    "StackLimit": "the stack limit of the economy ingame item, type is number, must be greater or equal to 0, 0 means no limit, only support NormalItem",
    "Action": {
      "ActionEntity": {
        "ServerName": "the server name of the economy ingame item, type is string"
      },
      "ActionType": "the action type of the economy ingame item, must be \"VirtualServerV2\", type is string"
    },
    "Tags": {
      "TagKey1": "TagVal1"
    },
    "DefaultCustomData": {
      "DefaultCustomDataKey1": "DefaultCustomDataVal1"
    }
  }
]

✨️ Request Example

{
  "ItemType": "NormalItem",
  "SearchKey": ""
}

describe-ingame-item

cli-load-json

{
  "ItemType": "required, the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
  "ItemId": "required, the id of the economy ingame item, type is string"
}

output

{
  "ItemId": "the id of the economy ingame item, type is string",
  "ItemType": "the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
  "DisplayName": "the display name of the economy ingame item, type is string",
  "Icon": "the icon of the economy ingame item, type is string",
  "Description": "the description of the economy ingame item, type is string",
  "DefaultPrices": [
    {
      "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
      "CurrencyCode": "the currency code of the economy ingame item, type is string",
      "CurrencyName": "the currency name of the economy ingame item, type is string",
      "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
    }
  ],
  "ItemContent": [
    {
      "ItemId": "the id of the economy ingame item, type is string",
      "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
    }
  ],
  "VirtualCurrencyContent": [
    {
      "CurrencyCode": "the currency code of the economy ingame item, type is string",
      "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
      "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
    }
  ],
  "ValidDuration": "the valid duration of the economy ingame item, type is number, must be greater than 0, unit is second",
  "IsUnique": "the is unique of the economy ingame item, type is boolean, only support NormalItem",
  "IsStackable": "the is stackable of the economy ingame item, type is boolean, only support NormalItem",
  "IsTradable": "the is tradable of the economy ingame item, type is boolean, only support NormalItem",
  "IsConsumable": "the is consumable of the economy ingame item, type is boolean, only support NormalItem",
  "StackLimit": "the stack limit of the economy ingame item, type is number, must be greater or equal to 0, 0 means no limit, only support NormalItem",
  "Action": {
    "ActionEntity": {
      "ServerName": "the server name of the economy ingame item, type is string"
    },
    "ActionType": "the action type of the economy ingame item, must be \"VirtualServerV2\", type is string"
  },
  "Tags": {
    "TagKey1": "TagVal1"
  },
  "DefaultCustomData": {
    "DefaultCustomDataKey1": "DefaultCustomDataVal1"
  }
}

✨️ Request Example

{
  "ItemType": "NormalItem",
  "ItemId": "item_uummofg6"
}

create-ingame-item

cli-load-json

{
  "ItemType": "required, the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
  "DisplayName": "required, the display name of the economy ingame item, type is string",
  "Icon": "required, the icon of the economy ingame item, type is string",
  "Description": "optional, the description of the economy ingame item, type is string",
  "DefaultPrices": [
    {
      "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
      "CurrencyCode": "the currency code of the economy ingame item, type is string",
      "CurrencyName": "the currency name of the economy ingame item, type is string",
      "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
    }
  ],
  "ItemContent": [
    {
      "ItemId": "the id of the economy ingame item, type is string",
      "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
    }
  ],
  "VirtualCurrencyContent": [
    {
      "CurrencyCode": "the currency code of the economy ingame item, type is string",
      "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
      "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
    }
  ],
  "ValidDuration": "optional, the valid duration of the economy ingame item, type is number, must be greater than 0, unit is second",
  "IsUnique": "optional, the is unique of the economy ingame item, type is boolean, only support NormalItem",
  "IsStackable": "optional, the is stackable of the economy ingame item, type is boolean, only support NormalItem",
  "IsTradable": "optional, the is tradable of the economy ingame item, type is boolean, only support NormalItem",
  "IsConsumable": "optional, the is consumable of the economy ingame item, type is boolean, only support NormalItem",
  "StackLimit": "the stack limit of the economy ingame item, type is number, must be greater or equal to 0, 0 means no limit, only support NormalItem",
  "Action": {
    "ActionEntity": {
      "ServerName": "the server name of the economy ingame item, type is string"
    },
    "ActionType": "the action type of the economy ingame item, must be \"VirtualServerV2\", type is string"
  },
  "Tags": {
    "TagKey1": "TagVal1"
  },
  "DefaultCustomData": {
    "DefaultCustomDataKey1": "DefaultCustomDataVal1"
  }
}

output

{}

✨️ Request Example

{
  "ItemId": "item_client_001",
  "ItemType": "NormalItem",
  "DisplayName": "will-test-client-item-1",
  "Description": "xxxxxxx",
  "Icon": "xxx.png",
  "DefaultPrices": [
    {
      "CurrencyType": "VirtualCurrency",
      "CurrencyCode": "LTC",
      "CurrencyName": "LTC",
      "Amount": 100
    },
    {
      "CurrencyType": "VirtualCurrency",
      "CurrencyCode": "EOS",
      "CurrencyName": "Diamond",
      "Amount": 200
    }
  ],
  "ItemContent": [],
  "VirtualCurrencyContent": [],
  "ValidDuration": 3660,
  "IsUnique": false,
  "IsStackable": true,
  "IsTradable": false,
  "IsConsumable": true,
  "StackLimit": 0,
  "Action": {
    "ActionEntity": {
      "ServerName": "will-test-pgos-docker-server-2"
    },
    "ActionType": "VirtualServerV2"
  },
  "Tags": {
    "Tag1": "Val1"
  },
  "DefaultCustomData": {
    "Key1": "Val1"
  }
}

update-ingame-item

cli-load-json

{
  "ItemType": "required, the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
  "ItemId": "required, the id of the economy ingame item, type is string",
  "DisplayName": "required, the display name of the economy ingame item, type is string",
  "Icon": "optional, the icon of the economy ingame item, type is string",
  "Description": "optional, the description of the economy ingame item, type is string",
  "DefaultPrices": [
    {
      "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
      "CurrencyCode": "the currency code of the economy ingame item, type is string",
      "CurrencyName": "the currency name of the economy ingame item, type is string",
      "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
    }
  ],
  "ItemContent": [
    {
      "ItemId": "the id of the economy ingame item, type is string",
      "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
    }
  ],
  "VirtualCurrencyContent": [
    {
      "CurrencyCode": "the currency code of the economy ingame item, type is string",
      "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
      "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
    }
  ],
  "ValidDuration": "optional, the valid duration of the economy ingame item, type is number, must be greater than 0, unit is second",
  "IsUnique": "optional, the is unique of the economy ingame item, type is boolean, only support NormalItem",
  "IsStackable": "optional, the is stackable of the economy ingame item, type is boolean, only support NormalItem",
  "IsTradable": "optional, the is tradable of the economy ingame item, type is boolean, only support NormalItem",
  "IsConsumable": "optional, the is consumable of the economy ingame item, type is boolean, only support NormalItem",
  "StackLimit": "the stack limit of the economy ingame item, type is number, must be greater or equal to 0, 0 means no limit, only support NormalItem",
  "Action": {
    "ActionEntity": {
      "ServerName": "the server name of the economy ingame item, type is string"
    },
    "ActionType": "the action type of the economy ingame item, must be \"VirtualServerV2\", type is string"
  },
  "Tags": {
    "TagKey1": "TagVal1"
  },
  "DefaultCustomData": {
    "DefaultCustomDataKey1": "DefaultCustomDataVal1"
  }
}

output

{}

✨️ Request Example

{
  "ItemId": "item_client_001",
  "ItemType": "NormalItem",
  "DisplayName": "will-test-client-item-1xxx",
  "Description": "xxxxxxx",
  "Icon": "xxx.png",
  "DefaultPrices": [
    {
      "CurrencyType": "VirtualCurrency",
      "CurrencyCode": "LTC",
      "CurrencyName": "LTC",
      "Amount": 100
    },
    {
      "CurrencyType": "VirtualCurrency",
      "CurrencyCode": "EOS",
      "CurrencyName": "Diamond",
      "Amount": 200
    }
  ],
  "ItemContent": [],
  "VirtualCurrencyContent": [],
  "ValidDuration": 3660,
  "IsUnique": false,
  "IsStackable": true,
  "IsTradable": false,
  "IsConsumable": true,
  "StackLimit": 0,
  "Action": {
    "ActionEntity": {
      "ServerName": "will-test-pgos-docker-server-2"
    },
    "ActionType": "VirtualServerV2"
  },
  "Tags": {
    "Tag1": "Val1"
  },
  "DefaultCustomData": {
    "Key1": "Val1"
  }
}

delete-ingame-item

cli-load-json

{
  "ItemType": "required, the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
  "ItemId": "required, the id of the economy ingame item, type is string"
}

output

{}

✨️ Request Example

{
  "ItemType": "NormalItem",
  "ItemId": "item_looq5ba2134"
}

export-ingame-item

cli-load-json

{}

output

[
  {
    "ItemId": "the id of the economy ingame item, type is string",
    "ItemType": "the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
    "DisplayName": "the display name of the economy ingame item, type is string",
    "Icon": "the icon of the economy ingame item, type is string",
    "Description": "the description of the economy ingame item, type is string",
    "DefaultPrices": [
      {
        "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
        "CurrencyCode": "the currency code of the economy ingame item, type is string",
        "CurrencyName": "the currency name of the economy ingame item, type is string",
        "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
      }
    ],
    "ItemContent": [
      {
        "ItemId": "the id of the economy ingame item, type is string",
        "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
      }
    ],
    "VirtualCurrencyContent": [
      {
        "CurrencyCode": "the currency code of the economy ingame item, type is string",
        "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
        "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
      }
    ],
    "ValidDuration": "the valid duration of the economy ingame item, type is number, must be greater than 0, unit is second",
    "IsUnique": "the is unique of the economy ingame item, type is boolean, only support NormalItem",
    "IsStackable": "the is stackable of the economy ingame item, type is boolean, only support NormalItem",
    "IsTradable": "the is tradable of the economy ingame item, type is boolean, only support NormalItem",
    "IsConsumable": "the is consumable of the economy ingame item, type is boolean, only support NormalItem",
    "StackLimit": "the stack limit of the economy ingame item, type is number, must be greater or equal to 0, 0 means no limit, only support NormalItem",
    "Action": {
      "ActionEntity": {
        "ServerName": "the server name of the economy ingame item, type is string"
      },
      "ActionType": "the action type of the economy ingame item, must be \"VirtualServerV2\", type is string"
    },
    "Tags": {
      "TagKey1": "TagVal1"
    },
    "DefaultCustomData": {
      "DefaultCustomDataKey1": "DefaultCustomDataVal1"
    }
  }
]

✨️ Request Example

{}

check-ingame-item

cli-load-json

{
  "Content": [
    {
      "ItemId": "the id of the economy ingame item, type is string",
      "ItemType": "the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
      "DisplayName": "the display name of the economy ingame item, type is string",
      "Icon": "the icon of the economy ingame item, type is string",
      "Description": "the description of the economy ingame item, type is string",
      "DefaultPrices": [
        {
          "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
          "CurrencyCode": "the currency code of the economy ingame item, type is string",
          "CurrencyName": "the currency name of the economy ingame item, type is string",
          "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
        }
      ],
      "ItemContent": [
        {
          "ItemId": "the id of the economy ingame item, type is string",
          "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
        }
      ],
      "VirtualCurrencyContent": [
        {
          "CurrencyCode": "the currency code of the economy ingame item, type is string",
          "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
          "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
        }
      ],
      "ValidDuration": "the valid duration of the economy ingame item, type is number, must be greater than 0, unit is second",
      "IsUnique": "the is unique of the economy ingame item, type is boolean, only support NormalItem",
      "IsStackable": "the is stackable of the economy ingame item, type is boolean, only support NormalItem",
      "IsTradable": "the is tradable of the economy ingame item, type is boolean, only support NormalItem",
      "IsConsumable": "the is consumable of the economy ingame item, type is boolean, only support NormalItem",
      "StackLimit": "the stack limit of the economy ingame item, type is number, must be greater or equal to 0, 0 means no limit, only support NormalItem",
      "Action": {
        "ActionEntity": {
          "ServerName": "the server name of the economy ingame item, type is string"
        },
        "ActionType": "the action type of the economy ingame item, must be \"VirtualServerV2\", type is string"
      },
      "Tags": {
        "TagKey1": "TagVal1"
      },
      "DefaultCustomData": {
        "DefaultCustomDataKey1": "DefaultCustomDataVal1"
      }
    }
  ]
}

output

{
  "FailedItems": [
    {
      "Key": "the key of the failed item, type is string",
      "Reason": "the reason of the failed item, type is string"
    }
  ]
}

✨️ Request Example

{
  "Content": [
    {
      "ItemId": "item_looq5ba2135",
      "ItemType": "NormalItem",
      "DisplayName": "will-test-client-item-1",
      "Description": "xxxxxxx",
      "Icon": "xxx.png",
      "DefaultPrices": [
        {
          "CurrencyType": "VirtualCurrency",
          "CurrencyCode": "LTC",
          "CurrencyName": "LTC",
          "Amount": 100
        },
        {
          "CurrencyType": "VirtualCurrency",
          "CurrencyCode": "EOS1",
          "CurrencyName": "Diamond",
          "Amount": 200
        }
      ],
      "ItemContent": [],
      "VirtualCurrencyContent": [],
      "ValidDuration": 3660,
      "IsUnique": false,
      "IsStackable": true,
      "IsTradable": false,
      "IsConsumable": true,
      "StackLimit": 0,
      "Action": {
        "ActionEntity": {
          "ServerName": "will-test-pgos-docker-server-2"
        },
        "ActionType": "VirtualServerV2"
      },
      "Tags": {
        "Tag1": "Val1"
      },
      "DefaultCustomData": {
        "Key1": "Val1"
      }
    }
  ]
}

import-ingame-item

提示

When you need to perform an import operation, it is recommended to use the check-ingame-item command to check whether the imported data meets the requirements. Select the appropriate Mode strategy when performing the import.

cli-load-json

{
  "Mode": "the mode of the import item, options are \"Merge\" or \"Override\", type is string",
  "Content": [
    {
      "ItemId": "the id of the economy ingame item, type is string",
      "ItemType": "the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
      "DisplayName": "the display name of the economy ingame item, type is string",
      "Icon": "the icon of the economy ingame item, type is string",
      "Description": "the description of the economy ingame item, type is string",
      "DefaultPrices": [
        {
          "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
          "CurrencyCode": "the currency code of the economy ingame item, type is string",
          "CurrencyName": "the currency name of the economy ingame item, type is string",
          "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
        }
      ],
      "ItemContent": [
        {
          "ItemId": "the id of the economy ingame item, type is string",
          "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
        }
      ],
      "VirtualCurrencyContent": [
        {
          "CurrencyCode": "the currency code of the economy ingame item, type is string",
          "CurrencyType": "the currency type of the economy ingame item, must be \"VirtualCurrency\" or \"MidasGlobalToken\", type is string",
          "Amount": "the amount of the economy ingame item, type is number, must be greater than 0"
        }
      ],
      "ValidDuration": "the valid duration of the economy ingame item, type is number, must be greater than 0, unit is second",
      "IsUnique": "the is unique of the economy ingame item, type is boolean, only support NormalItem",
      "IsStackable": "the is stackable of the economy ingame item, type is boolean, only support NormalItem",
      "IsTradable": "the is tradable of the economy ingame item, type is boolean, only support NormalItem",
      "IsConsumable": "the is consumable of the economy ingame item, type is boolean, only support NormalItem",
      "StackLimit": "the stack limit of the economy ingame item, type is number, must be greater or equal to 0, 0 means no limit, only support NormalItem",
      "Action": {
        "ActionEntity": {
          "ServerName": "the server name of the economy ingame item, type is string"
        },
        "ActionType": "the action type of the economy ingame item, must be \"VirtualServerV2\", type is string"
      },
      "Tags": {
        "TagKey1": "TagVal1"
      },
      "DefaultCustomData": {
        "DefaultCustomDataKey1": "DefaultCustomDataVal1"
      }
    }
  ]
}

output

{
  "AddedItems": ["the successfully added item, type is string"],
  "UpdatedItems": ["the successfully updated item, type is string"],
  "DeletedItems": ["the successfully deleted item, type is string"],
  "FailedItems": [
    {
      "Key": "the key of the failed item, type is string",
      "Reason": "the reason of the failed item, type is string"
    }
  ]
}

✨️ Request Example

{
  "Mode": "Merge",
  "Content": [
    {
      "ItemId": "item_looq5ba2137",
      "ItemType": "NormalItem",
      "DisplayName": "will-test-client-item-4",
      "Description": "xxxxxxx",
      "Icon": "xxx.png",
      "DefaultPrices": [
        {
          "CurrencyType": "VirtualCurrency",
          "CurrencyCode": "LTC",
          "CurrencyName": "LTC",
          "Amount": 100
        },
        {
          "CurrencyType": "VirtualCurrency",
          "CurrencyCode": "EOS",
          "CurrencyName": "Diamond",
          "Amount": 200
        }
      ],
      "ItemContent": [],
      "VirtualCurrencyContent": [],
      "ValidDuration": 3660,
      "IsUnique": false,
      "IsStackable": true,
      "IsTradable": false,
      "IsConsumable": true,
      "StackLimit": 0,
      "Action": {
        "ActionEntity": {
          "ServerName": "will-test-pgos-docker-server-2"
        },
        "ActionType": "VirtualServerV2"
      },
      "Tags": {
        "Tag1": "Val1"
      },
      "DefaultCustomData": {
        "Key1": "Val1"
      }
    }
  ]
}

Economy Platform Item Interface

export-platform-item

cli-load-json

{}

output

[
  {
    "ItemId": "the id of the economy ingame item, type is string",
    "ItemType": "the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
    "PlatformItems": [
      {
        "Platform": "the platform of the economy ingame item, only support Steam/Xbox/MidasGlobal now, type is string",
        "PlatformItemId": "the platform item id of the economy ingame item, type is string"
      }
    ]
  }
]

✨️ Request Example

{}

check-platform-item

cli-load-json

{
  "Content": [
    {
      "ItemId": "the id of the economy ingame item, type is string",
      "ItemType": "the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
      "PlatformItems": [
        {
          "Platform": "the platform of the economy ingame item, only support Steam/Xbox/MidasGlobal now, type is string",
          "PlatformItemId": "the platform item id of the economy ingame item, type is string"
        }
      ]
    }
  ]
}

output

{
  "FailedItems": [
    {
      "Key": "the key of the failed item, type is string",
      "Reason": "the reason of the failed item, type is string"
    }
  ]
}

✨️ Request Example

{
  "Content": [
    {
      "ItemId": "item_cyrbznez",
      "ItemType": "NormalItem",
      "PlatformItems": [
        {
          "Platform": "Steam",
          "PlatformItemId": "101"
        }
      ]
    }
  ]
}

import-platform-item

提示

When you need to perform an import operation, it is recommended to use the check-platform-item command to check whether the imported data meets the requirements. Select the appropriate Mode strategy when performing the import.

cli-load-json

{
  "Mode": "the mode of the import item, options are \"Merge\" or \"Override\", type is string",
  "Content": [
    {
      "ItemId": "the id of the economy ingame item, type is string",
      "ItemType": "the item type of the economy ingame item, must be \"NormalItem\" or \"BundleItem\" or \"ContainerItem\" or \"GeneratorItem\", type is string",
      "PlatformItems": [
        {
          "Platform": "the platform of the economy ingame item, only support Steam/Xbox/MidasGlobal now, type is string",
          "PlatformItemId": "the platform item id of the economy ingame item, type is string"
        }
      ]
    }
  ]
}

output

{}

✨️ Request Example

{
  "Mode": "Merge",
  "Content": [
    {
      "ItemId": "bundle_dqmbjsfq",
      "ItemType": "BundleItem",
      "PlatformItems": [
        {
          "Platform": "Steam",
          "PlatformItemId": "101"
        }
      ]
    }
  ]
}

Economy Store Interface

list-store

cli-load-json

{}

output

[
  {
    "StoreId": "the id of the economy store, type is string",
    "DisplayName": "the display name of the economy store, type is string",
    "Description": "the description of the economy store, type is string",
    "Tags": {
      "TagKey1": "TagVal1"
    }
  }
]

✨️ Request Example

{}

describe-store

cli-load-json

{
  "StoreId": "required, the id of the economy store, type is string"
}

output

{
  "StoreId": "the id of the economy store, type is string",
  "DisplayName": "the display name of the economy store, type is string",
  "Description": "the description of the economy store, type is string",
  "Tags": {
    "TagKey1": "TagVal1"
  }
}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2"
}

create-store

cli-load-json

{
  "StoreId": "required, the id of the economy store, type is string",
  "DisplayName": "required, the display name of the economy store, type is string",
  "Description": "optional, the description of the economy store, type is string",
  "Tags": {
    "TagKey1": "TagVal1"
  }
}

output

{}

✨️ Request Example

{
  "StoreId": "store_001",
  "DisplayName": "StoreSample002",
  "Description": "xxxx",
  "Tags": {
    "Tag1": "Val1"
  }
}

update-store

cli-load-json

{
  "StoreId": "required, the id of the economy store, type is string",
  "DisplayName": "required, the display name of the economy store, type is string",
  "Description": "optional, the description of the economy store, type is string",
  "Tags": {
    "TagKey1": "TagVal1"
  }
}

output

{}

✨️ Request Example

{
  "StoreId": "store_001",
  "DisplayName": "StoreSample002xxxx",
  "Description": "xxxxxxxx",
  "Tags": {
    "Tag1": "Val1xxx"
  }
}

delete-store

cli-load-json

{
  "StoreId": "required, the id of the economy store, type is string"
}

output

{}

✨️ Request Example

{
  "StoreId": "store_001"
}

export-store

cli-load-json

{}

output

[
  {
    "StoreId": "the id of the economy store, type is string",
    "DisplayName": "the display name of the economy store, type is string",
    "Description": "the description of the economy store, type is string",
    "Tags": {
      "TagKey1": "TagVal1"
    },
    "Categories": [
      {
        "CategoryId": "the id of the category, type is string",
        "Name": "the name of the category, type is string",
        "Description": "the description of the category, type is string",
        "Tags": {
          "TagKey1": "TagVal1"
        },
        "Status": "the status of the category, options are: Available, Disabled, type is string",
        "Type": "the type of the category, options are: Simple, Advanced, type is string",
        "ManualConfiguration": {
          "Periods": [
            {
              "PeriodId": "the id of the period, type is string",
              "StartTime": "the start time of the period, must be a second timestamp, type is number",
              "EndTime": "the end time of the period, must be a second timestamp, type is number",
              "StartTimeISO": "the start time of the period, type is string, use ISO 8601 date format",
              "EndTimeISO": "the end time of the period, type is string, use ISO 8601 date format",
              "StoreItemIds": ["the ids of the store items, type is string"]
            }
          ]
        },
        "RotationConfiguration": {
          "StartTime": "the start time of the rotation, must be a second timestamp, type is number",
          "EndTime": "the end time of the rotation, must be a second timestamp, type is number",
          "CycleLength": "the length of the cycle, type is number",
          "CycleLengthUnit": "the unit of the cycle length, options are: Hours, Days, type is string",
          "PublishPeriodLength": "the length of the publish period, type is number",
          "PublishPeriodLengthUnit": "the unit of the publish period length, options are: Hours, Days, type is string",
          "ItemsCount": "the count of the items, type is number",
          "ItemsRotationMode": "the mode of the rotation, options are: Random, Sequential, type is string"
        },
        "Order": "the order of the category, type is number"
      }
    ],
    "StoreItems": [
      {
        "StoreItemId": "the id of the store item, type is string",
        "CategoryId": "the id of the category, type is string",
        "ItemId": "the id of the item, type is string",
        "Tags": {
          "TagKey1": "TagVal1"
        },
        "Status": "the status of the store item, options are: Published, Disabled, Retired, type is string",
        "PriceMode": "the price mode of the store item, options are: UseDefaultPrice, CustomPrice, type is string",
        "PayPlatform": "the pay platform of the store item, options are: PGOS/Steam/Xbox/MidasGlobal, type is string",
        "SellingPrices": [
          {
            "CurrencyCode": "the currency code of the selling price, type is string",
            "Amount": "the amount of the selling price, type is number"
          }
        ],
        "DeductionPrices": {
          "<UniqueItemID>": [
            {
              "CurrencyCode": "the currency code of the deduction price, type is string",
              "Amount": "the amount of the deduction price, type is number"
            }
          ]
        }
      }
    ]
  }
]

✨️ Request Example

{}

check-store

cli-load-json

{
  "Content": [
    {
      "StoreId": "the id of the economy store, type is string",
      "DisplayName": "the display name of the economy store, type is string",
      "Description": "the description of the economy store, type is string",
      "Tags": {
        "TagKey1": "TagVal1"
      },
      "Categories": [
        {
          "CategoryId": "the id of the category, type is string",
          "Name": "the name of the category, type is string",
          "Description": "the description of the category, type is string",
          "Tags": {
            "TagKey1": "TagVal1"
          },
          "Status": "the status of the category, options are: Available, Disabled, type is string",
          "Type": "the type of the category, options are: Simple, Advanced, type is string",
          "ManualConfiguration": {
            "Periods": [
              {
                "PeriodId": "the id of the period, type is string",
                "StartTime": "the start time of the period, must be a second timestamp, type is number",
                "EndTime": "the end time of the period, must be a second timestamp, type is number",
                "StartTimeISO": "the start time of the period, type is string, use ISO 8601 date format",
                "EndTimeISO": "the end time of the period, type is string, use ISO 8601 date format",
                "StoreItemIds": ["the ids of the store items, type is string"]
              }
            ]
          },
          "RotationConfiguration": {
            "StartTime": "the start time of the rotation, must be a second timestamp, type is number",
            "EndTime": "the end time of the rotation, must be a second timestamp, type is number",
            "CycleLength": "the length of the cycle, type is number",
            "CycleLengthUnit": "the unit of the cycle length, options are: Hours, Days, type is string",
            "PublishPeriodLength": "the length of the publish period, type is number",
            "PublishPeriodLengthUnit": "the unit of the publish period length, options are: Hours, Days, type is string",
            "ItemsCount": "the count of the items, type is number",
            "ItemsRotationMode": "the mode of the rotation, options are: Random, Sequential, type is string"
          },
          "Order": "the order of the category, type is number"
        }
      ],
      "StoreItems": [
        {
          "StoreItemId": "the id of the store item, type is string",
          "CategoryId": "the id of the category, type is string",
          "ItemId": "the id of the item, type is string",
          "Tags": {
            "TagKey1": "TagVal1"
          },
          "Status": "the status of the store item, options are: Published, Disabled, Retired, type is string",
          "PriceMode": "the price mode of the store item, options are: UseDefaultPrice, CustomPrice, type is string",
          "PayPlatform": "the pay platform of the store item, options are: PGOS/Steam/Xbox/MidasGlobal, type is string",
          "SellingPrices": [
            {
              "CurrencyCode": "the currency code of the selling price, type is string",
              "Amount": "the amount of the selling price, type is number"
            }
          ],
          "DeductionPrices": {
            "<UniqueItemID>": [
              {
                "CurrencyCode": "the currency code of the deduction price, type is string",
                "Amount": "the amount of the deduction price, type is number"
              }
            ]
          }
        }
      ]
    }
  ]
}

output

{
  "FailedItems": [
    {
      "Key": "the key of the failed item, type is string",
      "Reason": "the reason of the failed item, type is string"
    }
  ]
}

✨️ Request Example

{
  "Content": [
    {
      "StoreId": "store_003",
      "DisplayName": "StoreSample003",
      "Description": "xxxx33",
      "Tags": {
        "Tag1": "Val1"
      },
      "Categories": [
        {
          "CategoryId": "category_4d14cwle",
          "Name": "Category002",
          "Description": "",
          "Tags": {
            "K1": "V1"
          },
          "Status": "Available",
          "Type": "Advanced",
          "ManualConfiguration": {
            "Periods": [
              {
                "PeriodId": "period_f19d5dy2",
                "StoreItemIds": ["store_item_fjktu9jm"],
                "StartTime": 1716429167,
                "EndTime": 1717033967
              }
            ]
          },
          "RotationConfiguration": {
            "StartTime": 1730649600,
            "EndTime": 1732896000,
            "CycleLength": 1,
            "CycleLengthUnit": "Days",
            "PublishPeriodLength": 1,
            "PublishPeriodLengthUnit": "Days",
            "ItemsCount": 1,
            "ItemsRotationMode": "Sequential"
          },
          "Order": 2
        }
      ],
      "StoreItems": [
        {
          "StoreItemId": "store_item_fjktu9jm",
          "CategoryId": "category_4d14cwle",
          "ItemId": "item_cyrbznez",
          "Status": "Published",
          "Tags": {},
          "PriceMode": "UseDefaultPrice",
          "PayPlatform": "PGOS",
          "SellingPrices": [
            {
              "CurrencyCode": "LTC",
              "Amount": 100
            }
          ],
          "DeductionPrices": {},
          "MaxPurchaseAmount": 0
        }
      ]
    }
  ]
}

import-store

提示

When you need to perform an import operation, it is recommended to use the check-store command to check whether the imported data meets the requirements. Select the appropriate Mode strategy when performing the import.

cli-load-json

{
  "Mode": "the mode of the import item, options are \"Merge\" or \"Override\", type is string",
  "Content": [
    {
      "StoreId": "the id of the economy store, type is string",
      "DisplayName": "the display name of the economy store, type is string",
      "Description": "the description of the economy store, type is string",
      "Tags": {
        "TagKey1": "TagVal1"
      },
      "Categories": [
        {
          "CategoryId": "the id of the category, type is string",
          "Name": "the name of the category, type is string",
          "Description": "the description of the category, type is string",
          "Tags": {
            "TagKey1": "TagVal1"
          },
          "Status": "the status of the category, options are: Available, Disabled, type is string",
          "Type": "the type of the category, options are: Simple, Advanced, type is string",
          "ManualConfiguration": {
            "Periods": [
              {
                "PeriodId": "the id of the period, type is string",
                "StartTime": "the start time of the period, must be a second timestamp, type is number",
                "EndTime": "the end time of the period, must be a second timestamp, type is number",
                "StartTimeISO": "the start time of the period, type is string, use ISO 8601 date format",
                "EndTimeISO": "the end time of the period, type is string, use ISO 8601 date format",
                "StoreItemIds": ["the ids of the store items, type is string"]
              }
            ]
          },
          "RotationConfiguration": {
            "StartTime": "the start time of the rotation, must be a second timestamp, type is number",
            "EndTime": "the end time of the rotation, must be a second timestamp, type is number",
            "CycleLength": "the length of the cycle, type is number",
            "CycleLengthUnit": "the unit of the cycle length, options are: Hours, Days, type is string",
            "PublishPeriodLength": "the length of the publish period, type is number",
            "PublishPeriodLengthUnit": "the unit of the publish period length, options are: Hours, Days, type is string",
            "ItemsCount": "the count of the items, type is number",
            "ItemsRotationMode": "the mode of the rotation, options are: Random, Sequential, type is string"
          },
          "Order": "the order of the category, type is number"
        }
      ],
      "StoreItems": [
        {
          "StoreItemId": "the id of the store item, type is string",
          "CategoryId": "the id of the category, type is string",
          "ItemId": "the id of the item, type is string",
          "Tags": {
            "TagKey1": "TagVal1"
          },
          "Status": "the status of the store item, options are: Published, Disabled, Retired, type is string",
          "PriceMode": "the price mode of the store item, options are: UseDefaultPrice, CustomPrice, type is string",
          "PayPlatform": "the pay platform of the store item, options are: PGOS/Steam/Xbox/MidasGlobal, type is string",
          "SellingPrices": [
            {
              "CurrencyCode": "the currency code of the selling price, type is string",
              "Amount": "the amount of the selling price, type is number"
            }
          ],
          "DeductionPrices": {
            "<UniqueItemID>": [
              {
                "CurrencyCode": "the currency code of the deduction price, type is string",
                "Amount": "the amount of the deduction price, type is number"
              }
            ]
          }
        }
      ]
    }
  ]
}

output

{
  "FailedItems": [
    {
      "Key": "the key of the failed item, type is string",
      "Reason": "the reason of the failed item, type is string"
    }
  ]
}

✨️ Request Example

{
  "Mode": "Merge",
  "Content": [
    {
      "StoreId": "store_003",
      "DisplayName": "StoreSample003",
      "Description": "xxxx33",
      "Tags": {
        "Tag1": "Val1"
      },
      "Categories": [
        {
          "CategoryId": "category_4d14cwle",
          "Name": "Category002",
          "Description": "",
          "Tags": {
            "K1": "V1"
          },
          "Status": "Available",
          "Type": "Advanced",
          "ManualConfiguration": {
            "Periods": [
              {
                "PeriodId": "period_f19d5dy2",
                "StoreItemIds": ["store_item_fjktu9jm"],
                "StartTime": 1716429167,
                "EndTime": 1717033967
              }
            ]
          },
          "RotationConfiguration": {
            "StartTime": 1730649600,
            "EndTime": 1732896000,
            "CycleLength": 1,
            "CycleLengthUnit": "Days",
            "PublishPeriodLength": 1,
            "PublishPeriodLengthUnit": "Days",
            "ItemsCount": 1,
            "ItemsRotationMode": "Sequential"
          },
          "Order": 2
        }
      ],
      "StoreItems": [
        {
          "StoreItemId": "store_item_fjktu9jm",
          "CategoryId": "category_4d14cwle",
          "ItemId": "item_cyrbznez",
          "Status": "Published",
          "Tags": {},
          "PriceMode": "UseDefaultPrice",
          "PayPlatform": "PGOS",
          "SellingPrices": [
            {
              "CurrencyCode": "LTC",
              "Amount": 100
            }
          ],
          "DeductionPrices": {},
          "MaxPurchaseAmount": 0
        }
      ]
    }
  ]
}

Economy Store Item Interface

list-store-item

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "CategoryId": "optional, the id of the category, type is string"
}

output

{
  "List": [
    {
      "StoreItemId": "the id of the store item, type is string",
      "CategoryId": "the id of the category, type is string",
      "ItemId": "the id of the item, type is string",
      "Tags": {
        "TagKey1": "TagVal1"
      },
      "Status": "the status of the store item, options are: Published, Disabled, Retired, type is string",
      "PriceMode": "the price mode of the store item, options are: UseDefaultPrice, CustomPrice, type is string",
      "PayPlatform": "the pay platform of the store item, options are: PGOS/Steam/Xbox/MidasGlobal, type is string",
      "SellingPrices": [
        {
          "CurrencyCode": "the currency code of the selling price, type is string",
          "Amount": "the amount of the selling price, type is number"
        }
      ],
      "DeductionPrices": {
        "<UniqueItemID>": [
          {
            "CurrencyCode": "the currency code of the deduction price, type is string",
            "Amount": "the amount of the deduction price, type is number"
          }
        ]
      },
      "MaxPurchaseAmount": "required, the max purchase amount of the store item, 0 means no limit, type is number",
      "CreatedTime": "the created time of the store item, type is string, use ISO 8601 date format",
      "UpdatedTime": "the updated time of the store item, type is string, use ISO 8601 date format"
    }
  ],
  "Total": "the total number of the store items, type is number"
}

✨️ Request Example

{
  "StoreId": "store_xxxxxx",
  "CategoryId": "catrgory_xxxxxx"
}

describe-store-item

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "StoreItemId": "required, the id of the store item, type is string"
}

output

{
  "StoreItemId": "the id of the store item, type is string",
  "CategoryId": "the id of the category, type is string",
  "ItemId": "the id of the item, type is string",
  "Tags": {
    "TagKey1": "TagVal1"
  },
  "Status": "the status of the store item, options are: Published, Disabled, Retired, type is string",
  "PriceMode": "the price mode of the store item, options are: UseDefaultPrice, CustomPrice, type is string",
  "PayPlatform": "the pay platform of the store item, options are: PGOS/Steam/Xbox/MidasGlobal, type is string",
  "SellingPrices": [
    {
      "CurrencyCode": "the currency code of the selling price, type is string",
      "Amount": "the amount of the selling price, type is number"
    }
  ],
  "DeductionPrices": {
    "<UniqueItemID>": [
      {
        "CurrencyCode": "the currency code of the deduction price, type is string",
        "Amount": "the amount of the deduction price, type is number"
      }
    ]
  },
  "MaxPurchaseAmount": "required, the max purchase amount of the store item, 0 means no limit, type is number",
  "CreatedTime": "the created time of the store item, type is string, use ISO 8601 date format",
  "UpdatedTime": "the updated time of the store item, type is string, use ISO 8601 date format"
}

✨️ Request Example

{
  "StoreId": "store_xxxxxx",
  "StoreItemId": "store_item_xxxxxx"
}

create-store-item

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "StoreItemId": "required, the id of the store item, type is string",
  "CategoryId": "required, the id of the category, type is string",
  "ItemId": "required, the id of the ingame item, type is string",
  "PriceMode": "required, the price mode of the store item, options are: UseDefaultPrice, CustomPrice, type is string",
  "PayPlatform": "the pay platform of the store item, options are: PGOS/Steam/Xbox/MidasGlobal, type is string",
  "SellingPrices": [
    {
      "CurrencyCode": "the currency code of the selling price, type is string",
      "Amount": "the amount of the selling price, type is number"
    }
  ],
  "DeductionPrices": {
    "<UniqueItemID>": [
      {
        "CurrencyCode": "the currency code of the deduction price, type is string",
        "Amount": "the amount of the deduction price, type is number"
      }
    ]
  },
  "MaxPurchaseAmount": "required, the max purchase amount of the store item, 0 means no limit, type is number",
  "Tags": {
    "TagKey1": "TagVal1"
  }
}

output

{}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "StoreItemId": "store_item_jg6pshxd",
  "CategoryId": "catrgory_y11ykqr0",
  "ItemId": "item_5m4r8ycy",
  "Tags": {
    "tag_1": "value_1",
    "tag_2": "value_2"
  },
  "PriceMode": "UseDefaultPrice",
  "PayPlatform": "PGOS",
  "SellingPrices": [],
  "DeductionPrices": {
    "item_kf0vl4wf": [
      {
        "CurrencyCode": "BTC",
        "Amount": 50
      }
    ]
  },
  "MaxPurchaseAmount": 100
}

update-store-item

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "StoreItemId": "required, the id of the store item, type is string",
  "CategoryId": "required, the id of the category, type is string",
  "PriceMode": "required, the price mode of the store item, options are: UseDefaultPrice, CustomPrice, type is string",
  "PayPlatform": "the pay platform of the store item, options are: PGOS/Steam/Xbox/MidasGlobal, type is string",
  "SellingPrices": [
    {
      "CurrencyCode": "the currency code of the selling price, type is string",
      "Amount": "the amount of the selling price, type is number"
    }
  ],
  "DeductionPrices": {
    "<UniqueItemID>": [
      {
        "CurrencyCode": "the currency code of the deduction price, type is string",
        "Amount": "the amount of the deduction price, type is number"
      }
    ]
  },
  "MaxPurchaseAmount": "required, the max purchase amount of the store item, 0 means no limit, type is number",
  "Tags": {
    "TagKey1": "TagVal1"
  }
}

output

{}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "StoreItemId": "store_item_jg6pshxd",
  "CategoryId": "catrgory_y11ykqr0",
  "Tags": {
    "tag_1": "value_1",
    "tag_2": "value_2",
    "tag_3": "value_3"
  },
  "PriceMode": "CustomPrice",
  "PayPlatform": "PGOS",
  "SellingPrices": [
    {
      "CurrencyCode": "BTC",
      "Amount": 50
    }
  ],
  "DeductionPrices": {
    "item_kf0vl4wf": [
      {
        "CurrencyCode": "BTC",
        "Amount": 50
      }
    ],
    "item_pycaigcc": [
      {
        "CurrencyCode": "BTC",
        "Amount": 100
      }
    ]
  },
  "MaxPurchaseAmount": 100
}

delete-store-item

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "StoreItemId": "required, the id of the store item, type is string"
}

output

{}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "StoreItemId": "store_item_jg6pshxd"
}

enable-store-item

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "StoreItemId": "required, the id of the store item, type is string"
}

output

{}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "StoreItemId": "store_item_jg6pshxd"
}

disable-store-item

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "StoreItemId": "required, the id of the store item, type is string"
}

output

{}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "StoreItemId": "store_item_jg6pshxd"
}

Economy Store Category Interface

list-store-category

cli-load-json

{
  "StoreId": "required, the id of the store, type is string"
}

output

{
  "List": [
    {
      "CategoryId": "the id of the category, type is string",
      "Name": "the name of the category, type is string",
      "Content": "the content of the category, type is array",
      "ContentLength": "the length of the content, type is number",
      "Description": "the description of the category, type is string",
      "Tags": {
        "TagKey1": "TagVal1"
      },
      "Status": "the status of the category, options are: Available, Disabled, type is string",
      "Type": "the type of the category, options are: Simple, Advanced, type is string",
      "ManualConfiguration": {
        "Periods": [
          {
            "PeriodId": "the id of the period, type is string",
            "StartTime": "the start time of the period, must be a second timestamp, type is number",
            "EndTime": "the end time of the period, must be a second timestamp, type is number",
            "StartTimeISO": "the start time of the period, type is string, use ISO 8601 date format",
            "EndTimeISO": "the end time of the period, type is string, use ISO 8601 date format",
            "StoreItemIds": ["the ids of the store items, type is string"]
          }
        ]
      },
      "RotationConfiguration": {
        "StartTime": "the start time of the rotation, must be a second timestamp, type is number",
        "EndTime": "the end time of the rotation, must be a second timestamp, type is number",
        "CycleLength": "the length of the cycle, type is number",
        "CycleLengthUnit": "the unit of the cycle length, options are: Hours, Days, type is string",
        "PublishPeriodLength": "the length of the publish period, type is number",
        "PublishPeriodLengthUnit": "the unit of the publish period length, options are: Hours, Days, type is string",
        "ItemsCount": "the count of the items, type is number",
        "ItemsRotationMode": "the mode of the rotation, options are: Random, Sequential, type is string"
      },
      "Order": "the order of the category, type is number",
      "CreatedTime": "the created time of the category, type is string, use ISO 8601 date format",
      "UpdatedTime": "the updated time of the category, type is string, use ISO 8601 date format"
    }
  ],
  "Total": "the total number of the categories, type is number"
}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2"
}

describe-store-category

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "CategoryId": "required, the id of the category, type is string"
}

output

{
  "CategoryId": "the id of the category, type is string",
  "Name": "the name of the category, type is string",
  "Content": "the content of the category, type is array",
  "ContentLength": "the length of the content, type is number",
  "Description": "the description of the category, type is string",
  "Tags": {
    "TagKey1": "TagVal1"
  },
  "Status": "the status of the category, options are: Available, Disabled, type is string",
  "Type": "the type of the category, options are: Simple, Advanced, type is string",
  "ManualConfiguration": {
    "Periods": [
      {
        "PeriodId": "the id of the period, type is string",
        "StartTime": "the start time of the period, must be a second timestamp, type is number",
        "EndTime": "the end time of the period, must be a second timestamp, type is number",
        "StartTimeISO": "the start time of the period, type is string, use ISO 8601 date format",
        "EndTimeISO": "the end time of the period, type is string, use ISO 8601 date format",
        "StoreItemIds": ["the ids of the store items, type is string"]
      }
    ]
  },
  "RotationConfiguration": {
    "StartTime": "the start time of the rotation, must be a second timestamp, type is number",
    "EndTime": "the end time of the rotation, must be a second timestamp, type is number",
    "CycleLength": "the length of the cycle, type is number",
    "CycleLengthUnit": "the unit of the cycle length, options are: Hours, Days, type is string",
    "PublishPeriodLength": "the length of the publish period, type is number",
    "PublishPeriodLengthUnit": "the unit of the publish period length, options are: Hours, Days, type is string",
    "ItemsCount": "the count of the items, type is number",
    "ItemsRotationMode": "the mode of the rotation, options are: Random, Sequential, type is string"
  },
  "Order": "the order of the category, type is number",
  "CreatedTime": "the created time of the category, type is string, use ISO 8601 date format",
  "UpdatedTime": "the updated time of the category, type is string, use ISO 8601 date format"
}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "CategoryId": "catrgory_ibg96q6d"
}

create-store-category

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "Name": "required, the name of the category, type is string",
  "Description": "optional, the description of the category, type is string",
  "Order": "optional, the order of the category, default is 0, type is number",
  "Status": "optional, the status of the category, options are: Available, Disabled, default is Disabled, type is string",
  "Type": "optional, the type of the category, options are: Simple, Advanced, default is Simple, type is string",
  "Tags": {
    "TagKey1": "TagVal1"
  }
}

output

{}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "CategoryId": "catrgory_ibg96q6d",
  "Name": "CategoryByClient",
  "Description": "Category Description",
  "Order": 1,
  "Status": "Disabled",
  "Type": "Simple",
  "Tags": {
    "tag1": "value1",
    "tag2": "value2"
  }
}

update-store-category

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "CategoryId": "required, the id of the category, type is string",
  "Name": "required, the name of the category, type is string",
  "Description": "optional, the description of the category, type is string",
  "Order": "optional, the order of the category, type is number",
  "Tags": {
    "TagKey1": "TagVal1"
  }
}

output

{}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "CategoryId": "catrgory_ibg96q6d",
  "Name": "CategoryByClientxxxx",
  "Description": "Category Description xxxx",
  "Order": 1,
  "Tags": {
    "tag1": "value1",
    "tag2": "value2",
    "tag3": "value3"
  }
}

delete-store-category

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "CategoryId": "required, the id of the category, type is string"
}

output

{}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "CategoryId": "catrgory_ibg96q6d"
}

enable-store-category

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "CategoryId": "required, the id of the category, type is string"
}

output

{}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "CategoryId": "catrgory_ibg96q6d"
}

disable-store-category

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "CategoryId": "required, the id of the category, type is string"
}

output

{}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "CategoryId": "catrgory_ibg96q6d"
}

set-store-category-schedule

cli-load-json

{
  "StoreId": "required, the id of the store, type is string",
  "CategoryId": "required, the id of the category, type is string",
  "ManualConfiguration": {
    "Periods": [
      {
        "PeriodId": "required, the id of the period, type is string",
        "StartTime": "required, the start time of the period, must be a second timestamp, type is number",
        "EndTime": "required, the end time of the period, must be a second timestamp, type is number",
        "StoreItemIds": ["optional, the ids of the store items, type is string"]
      }
    ]
  },
  "RotationConfiguration": {
    "StartTime": "the start time of the rotation, must be a second timestamp, type is number",
    "EndTime": "the end time of the rotation, must be a second timestamp, type is number",
    "CycleLength": "the length of the cycle, type is number",
    "CycleLengthUnit": "the unit of the cycle length, options are: Hours, Days, type is string",
    "PublishPeriodLength": "the length of the publish period, type is number",
    "PublishPeriodLengthUnit": "the unit of the publish period length, options are: Hours, Days, type is string",
    "ItemsCount": "the count of the items, type is number",
    "ItemsRotationMode": "the mode of the rotation, options are: Random, Sequential, type is string"
  }
}

output

{}

✨️ Request Example

{
  "StoreId": "store_ovxw8by2",
  "CategoryId": "catrgory_ibg96q6d",
  "ManualConfiguration": {
    "Periods": [
      {
        "PeriodId": "period_7v5kzimr",
        "StoreItemIds": ["store_item_2d66cbh4", "store_item_oxhltmbi", "store_item_yjjkz7jp"],
        "StartTime": 1713232172,
        "EndTime": 1713404972
      },
      {
        "PeriodId": "period_dumappiu",
        "StoreItemIds": [],
        "StartTime": 1713491372,
        "EndTime": 1713664172
      }
    ]
  },
  "RotationConfiguration": {
    "StartTime": 1730649600,
    "EndTime": 1732896000,
    "CycleLength": 1,
    "CycleLengthUnit": "Days",
    "PublishPeriodLength": 1,
    "PublishPeriodLengthUnit": "Days",
    "ItemsCount": 1,
    "ItemsRotationMode": "Sequential"
  }
}

reset-store-category-rotation-schedule

cli-load-json

{
  "CategoryId": "required, the id of the category, type is string"
}

output

{}

✨️ Request Example

{
  "CategoryId": "catrgory_ibg96q6d"
}

modify-store-category-rotation-periods

cli-load-json

{
  "CategoryId": "required, the id of the category, type is string",
  "PeriodId": "required, the id of the period, type is string",
  "StoreItemIds": ["optional, the ids of the store items, type is string"]
}

output

{}

✨️ Request Example

{
  "CategoryId": "catrgory_ibg96q6d",
  "PeriodId": "period_7v5kzimr",
  "StoreItemIds": ["store_item_2d66cbh4", "store_item_oxhltmbi", "store_item_yjjkz7jp"]
}

list-store-category-rotation-periods

cli-load-json

{
  "CategoryId": "required, the id of the category, type is string",
  "StartTime": "optional, the start time of the period, must be a second timestamp, type is number",
  "EndTime": "optional, the end time of the period, must be a second timestamp, type is number",
  "Count": "optional, the count of the periods, default is 10, type is number",
  "Offset": "optional, the offset of the periods, default is 0, type is number"
}

output

{
  "NextOffset": "the next offset of the periods, type is number",
  "TotalNum": "the total number of the periods, type is number",
  "Periods": [
    {
      "PeriodId": "the id of the period, type is string",
      "StoreItemIds": ["the ids of the store items, type is string"],
      "StartTime": "the start time of the period, must be a second timestamp, type is number",
      "StartTimeISO": "the start time of the period, type is string, use ISO 8601 date format",
      "EndTime": "the end time of the period, must be a second timestamp, type is number",
      "EndTimeISO": "the end time of the period, type is string, use ISO 8601 date format"
    }
  ]
}

✨️ Request Example

{
  "CategoryId": "category_u2hprv1h",
  "StartTime": 0,
  "EndTime": 0,
  "Count": 100,
  "Offset": 0
}

Goal Interface

list-goal

cli-load-json

{
  "QueryKey": "optional, the goal name to search, type is string",
  "Tags": ["optional, the tag of the goal, type is string"],
  "Offset": "required, the start offset of the result list, start from 0, type is number",
  "Count": "required, the count of the result list, max is 50, type is number"
}

output

{
  "List": [
    {
      "AchieveData": {
        "AlgorithmType": "value: `Absolute Value` | `Increment Value`, type is string",
        "AchieveData": "the data key, type is string",
        "AchieveDataSource": "value: `Player Data` | `Virtual Currency`, type is string"
      },
      "AchieveDataValue": "the achieve data value, type is number",
      "CreatedTime": "created time, type is string",
      "Description": "type is string",
      "GoalId": "the goal id, type is string",
      "Icon": "the goal icon, type is string",
      "Name": "the goal name, type is string",
      "Rewards": {
        "ItemContents": [
          {
            "ItemId": "the item id, type is string",
            "Amount": "the item amount, type is number"
          }
        ],
        "VcContents": [
          {
            "CurrencyCode": "the currency code, type is string",
            "Amount": "the item amount, type is number"
          }
        ]
      },
      "Tags": ["the tag, type is string"],
      "Type": "value: Simple | Hyper, type is string"
    }
  ]
}

describe-goal

cli-load-json

{
  "GoalId": "required, the goal id, type is string"
}

output

{
  "AchieveData": {
    "AlgorithmType": "value: `Absolute Value` | `Increment Value`, type is string",
    "AchieveData": "the data key, type is string",
    "AchieveDataSource": "value: `Player Data` | `Virtual Currency`, type is string"
  },
  "AchieveDataValue": "the achieve data value, type is number",
  "CreatedTime": "created time, type is string",
  "Description": "type is string",
  "GoalId": "the goal id, type is string",
  "Icon": "the goal icon, type is string",
  "Name": "the goal name, type is string",
  "Rewards": {
    "ItemContents": [
      {
        "ItemId": "the item id, type is string",
        "Amount": "the item amount, type is number"
      }
    ],
    "VcContents": [
      {
        "CurrencyCode": "the currency code, type is string",
        "Amount": "the item amount, type is number"
      }
    ]
  },
  "Tags": ["the tag, type is string"],
  "Type": "value: Simple | Hyper, type is string"
}

create-goal

cli-load-json

{
  "GoalInfo": {
    "GoalId": "required, the goal id, type is string",
    "Name": "required, the goal name, type is string",
    "Description": "optional, type is string",
    "Tags": ["optional, the tag, type is string"],
    "Type": "required, value: Simple | Hyper, type is string",
    "AchieveDataSource": "required, value: `Player Data` | `Virtual Currency`, type is string",
    "AchieveData": "required, the data key, type is string",
    "Icon": "optional, the goal icon, type is string",
    "AchieveDataValue": "required, the achieve data value, type is number",
    "AlgorithmType": "required, value: `Absolute Value` | `Increment Value`, type is string",
    "Rewards": {
      "ItemContents": [
        {
          "ItemId": "the item id, type is string",
          "Amount": "the item amount, type is number"
        }
      ],
      "VcContents": [
        {
          "CurrencyCode": "the currency code, type is string",
          "Amount": "the item amount, type is number"
        }
      ]
    }
  }
}

output

{}

update-goal

cli-load-json

{
  "GoalInfo": {
    "GoalId": "required, the goal id, type is string",
    "Name": "required, the goal name, type is string",
    "Description": "optional, type is string",
    "Tags": ["optional, the tag, type is string"],
    "Type": "required, value: Simple | Hyper, type is string",
    "AchieveDataSource": "required, value: `Player Data` | `Virtual Currency`, type is string",
    "AchieveData": "required, the data key, type is string",
    "Icon": "optional, the goal icon, type is string",
    "AchieveDataValue": "required, the achieve data value, type is number",
    "AlgorithmType": "required, value: `Absolute Value` | `Increment Value`, type is string",
    "Rewards": {
      "ItemContents": [
        {
          "ItemId": "the item id, type is string",
          "Amount": "the item amount, type is number"
        }
      ],
      "VcContents": [
        {
          "CurrencyCode": "the currency code, type is string",
          "Amount": "the item amount, type is number"
        }
      ]
    }
  }
}

output

{}

delete-goal

cli-load-json

{
  "GoalId": "required, the goal id, type is string"
}

output

{}

list-pass-by-goal

cli-load-json

{
  "GoalId": "required, the goal id, type is string"
}

output

{
  "List": [
    {
      "Description": "type is string",
      "Icon": "the pass icon, type is string",
      "ItemId": "the item id, type is string",
      "ItemName": "the item name, type is string",
      "Name": "the pass name, type is string",
      "PassId": "the pass id, type is string"
    }
  ]
}

update-passes-by-goal

cli-load-json

{
  "GoalId": "required, the goal id, type is string",
  "Passes": [
    {
      "PassId": "required, the pass id, type is string",
      "Name": "required, the pass name, type is string",
      "Description": "optional, type is string",
      "Icon": "optional, the pass icon, type is string",
      "ItemId": "required, the item id, type is string"
    }
  ]
}

output

{}

list-tier-by-goal

cli-load-json

{
  "GoalId": "required, the goal id, type is string"
}

output

{
  "List": [
    {
      "AchieveValue": "the achieve value, type is number",
      "Name": "the tier name, type is string",
      "RewardList": [
        {
          "PassId": "the pass id, type is string",
          "Rewards": {
            "ItemContents": [
              {
                "ItemId": "the item id, type is string",
                "Amount": "the item amount, type is number"
              }
            ],
            "VcContents": [
              {
                "CurrencyCode": "the currency code, type is string",
                "Amount": "the item amount, type is number"
              }
            ]
          }
        }
      ],
      "TierId": "the tier id, type is string"
    }
  ]
}

describe-tier-by-goal

cli-load-json

{
  "GoalId": "required, the goal id, type is string",
  "TierId": "required, the tier id, type is string"
}

output

{
  "AchieveValue": "the achieve value, type is number",
  "Name": "the tier name, type is string",
  "RewardList": [
    {
      "PassId": "the pass id, type is string",
      "Rewards": {
        "ItemContents": [
          {
            "ItemId": "the item id, type is string",
            "Amount": "the item amount, type is number"
          }
        ],
        "VcContents": [
          {
            "CurrencyCode": "the currency code, type is string",
            "Amount": "the item amount, type is number"
          }
        ]
      }
    }
  ],
  "TierId": "the tier id, type is string"
}

update-tiers-by-goal

cli-load-json

{
  "GoalId": "required, the goal id, type is string",
  "Tiers": [
    {
      "TierId": "required, the tier id, type is string",
      "Name": "required, the tier name, type is string",
      "AchieveValue": "required, the achieve value, type is number",
      "RewardsList": [
        {
          "Rewards": {
            "ItemContents": [
              {
                "ItemId": "the item id, type is string",
                "Amount": "the item amount, type is number"
              }
            ],
            "VcContents": [
              {
                "CurrencyCode": "the currency code, type is string",
                "Amount": "the item amount, type is number"
              }
            ]
          }
        }
      ]
    }
  ]
}

output

{}

update-tier

cli-load-json

{
  "GoalId": "required, the goal id, type is string",
  "Tier": {
    "TierId": "required, the tier id, type is string",
    "Name": "required, the tier name, type is string",
    "AchieveValue": "required, the achieve value, type is number",
    "RewardsList": [
      {
        "Rewards": {
          "ItemContents": [
            {
              "ItemId": "the item id, type is string",
              "Amount": "the item amount, type is number"
            }
          ],
          "VcContents": [
            {
              "CurrencyCode": "the currency code, type is string",
              "Amount": "the item amount, type is number"
            }
          ]
        }
      }
    ]
  }
}

output

{}

delete-tiers

cli-load-json

{
  "GoalId": "required, the goal id, type is string",
  "TierIds": ["required, the tier id, type is string"]
}

output

{}

create-tier

cli-load-json

{
  "GoalId": "required, the goal id, type is string",
  "Tier": {
    "TierId": "required, the tier id, type is string",
    "Name": "required, the tier name, type is string",
    "AchieveValue": "required, the achieve value, type is number",
    "RewardsList": [
      {
        "Rewards": {
          "ItemContents": [
            {
              "ItemId": "the item id, type is string",
              "Amount": "the item amount, type is number"
            }
          ],
          "VcContents": [
            {
              "CurrencyCode": "the currency code, type is string",
              "Amount": "the item amount, type is number"
            }
          ]
        }
      }
    ]
  }
}

output

{}

Schedule Interface

list-schedule

cli-load-json

{
  "QueryKey": "optional, the schedule name to search, type is string",
  "Offset": "optional, the start offset of the result list, start from 0, type is number",
  "Count": "optional, the count of the result list, max is 50, type is number"
}

output

{
  "List": [
    {
      "CreatedTime": "the created time, type is number",
      "Description": "type is string",
      "MailTemplateName": "the mail template name, type is string",
      "Name": "the schedule name, type is string",
      "Periods": [
        {
          "EndTime": "the period end time, type is string",
          "Goals": ["the goal id, type is string"],
          "PeriodId": "the period id, type is string",
          "StartTime": "the period start time, type is string"
        }
      ],
      "PublishEndTime": "the schedule publish end time, type is string",
      "PublishStartTime": "the schedule publish start time, type is string",
      "RewardsWay": "value: `Mannual`|`By Mail`, type is string",
      "ScheduleId": "the schedule id, type is string"
    }
  ]
}

update-schedule

cli-load-json

{
  "Schedule": {
    "ScheduleId": "required, the schedule id, type is string",
    "RewardsWay": "required, value: `Mannual`|`By Mail`, type is string",
    "Periods": [
      {
        "StartTime": "required, the period start time, type is string",
        "EndTime": "required, the period end time, type is string"
      }
    ],
    "PublishStartTime": "required, the schedule publish start time, type is string",
    "PublishEndTime": "required, the schedule publish end time, type is string",
    "MailTemplateName": "required, the mail template name, type is string"
  }
}

output

{}

publish-schedule

cli-load-json

{
  "ScheduleId": "required, the schedule id, type is string",
  "PublishStartTime": "required, the schedule publish start time, type is string",
  "PublishEndTime": "required, the schedule publish end time, type is string"
}

output

{}

retire-schedule

cli-load-json

{
  "ScheduleId": "required, the schedule id, type is string"
}

output

{}

create-schedule

cli-load-json

{
  "Schedule": {
    "ScheduleId": "required, the schedule id, type is string",
    "Name": "required, the schedule name, type is string",
    "RewardsWay": "required, value: `Mannual`|`By Mail`, type is string",
    "Periods": [
      {
        "StartTime": "required, the period start time, type is string",
        "EndTime": "required, the period end time, type is string"
      }
    ],
    "PublishStartTime": "required, the schedule publish start time, type is string",
    "PublishEndTime": "required, the schedule publish end time, type is string",
    "MailTemplateName": "required, the mail template name, type is string"
  }
}

output

{}

describe-schedule

cli-load-json

{
  "ScheduleId": "required, the schedule id, type is string"
}

output

{
  "CreatedTime": "the created time, type is string",
  "Description": "type is string",
  "MailTemplateName": "the mail template name, type is string",
  "Name": "the schedule name, type is string",
  "Periods": [
    {
      "EndTime": "the period end time, type is string",
      "Goals": ["the goal id, type is string"],
      "PeriodId": "the period id, type is string",
      "StartTime": "the period start time, type is string"
    }
  ],
  "PublishEndTime": "the schedule publish end time, type is string",
  "PublishStartTime": "the schedule publish start time, type is string",
  "RewardsWay": "value: `Mannual`|`By Mail`, type is string",
  "ScheduleId": "the schedule id, type is string"
}

delete-schedules

cli-load-json

{
  "ScheduleIds": ["required, the schedule id, type is string"]
}

output

{}

Cycle Interface

list-cycle

cli-load-json

{}

output

{
  "List": [
    {
      "CycleId": "the cycle id, type is string",
      "CycleName": "the cycle name, type is string",
      "CycleType": "the cycle type, daily, weekly, monthly, seasonal, type is string",
      "Description": "the description, type is string",
      "EnableEndDate": "the end date is enable or not, type is boolean",
      "EndDate": "the end date, type is string",
      "ResetMonthDay": "the day of reset month, type is number, optional",
      "ResetSeasonDays": "the day of reset season, type is number, optional",
      "ResetTimeHour": "the hour of reset time, type is number, optional",
      "ResetTimeMinute": "the minute of reset time, type is number, optional",
      "ResetWeekDay": "the day of reset week, type is number, optional",
      "RoundInfo": {
        "CycleRoundSeq": "the serial number of cycle, type is number",
        "RoundStartTime": "the start time of round, type is string",
        "RoundEndTime": "the end time of round, type is string"
      },
      "StartDate": "the start time of cycle, type is string",
      "Stats": [
        {
          "StatName": "the stat name, type is string",
          "BoundTime": "the bind time, type is string"
        }
      ]
    }
  ]
}

describe-cycle-by-name

cli-load-json

{
  "CycleName": "required, the cycle name to search, type is string"
}

output

{
  "Cycle": {
    "CycleId": "the cycle id, type is string",
    "CycleName": "the cycle name, type is string",
    "CycleType": "the cycle type, daily, weekly, monthly, seasonal, type is string",
    "Description": "the description, type is string",
    "EnableEndDate": "the end date is enable or not, type is boolean",
    "EndDate": "the end date, type is string",
    "ResetMonthDay": "the day of reset month, type is number, optional",
    "ResetSeasonDays": "the day of reset season, type is number, optional",
    "ResetTimeHour": "the hour of reset time, type is number, optional",
    "ResetTimeMinute": "the minute of reset time, type is number, optional",
    "ResetWeekDay": "the day of reset week, type is number, optional",
    "StartDate": "the start time of cycle, type is string"
  },
  "StatList": [
    {
      "StatName": "the stat name, type is string",
      "Key": "the key of stat, type is string",
      "Value": "the value of key, type is string",
      "SecondaryValue": "the secondary value of key, type is string",
      "Tags": ["the tag of stat, type is string"],
      "AggregateType": "the type of aggregate, OVERRIDE, SUM, MAX, MIN"
    }
  ],
  "RoundInfo": {
    "CycleRoundSeq": "the serial number of cycle, type is number",
    "RoundStartTime": "the start time of round, type is string",
    "RoundEndTime": "the end time of round, type is string"
  }
}

describe-cycle-stat-items

cli-load-json

{
  "StatName": "required, the stat name to search, type is string",
  "Keys": ["required, the key to search, type is string"]
}

output

{
  "key": {
    "CycleName": "cycleName",
    "CycleRoundSeq": "the cycle name, type is string",
    "Value": "the value of cycle, type is string",
    "SecondaryValue": "the second value of cycle, type is string",
    "UpdatedTime": "the update time, type is string"
  }
}

describe-binded-cycles

cli-load-json

{
  "StatName": "required, the stat name to search, type is string"
}

output

{
  "List": ["the object of cycle"]
}

bind-stat-to-cycle

cli-load-json

{
  "StatName": "required, the stat name to bind, type is string",
  "CycleName": "required, the cycle name for binding, type is string"
}

output

{}

unbind-stat-from-cycle

cli-load-json

{
  "StatName": "required, the stat name to bind, type is string",
  "CycleName": "required, the cycle name for binding, type is string"
}

output

{}

create-cycle

cli-load-json

{
  "CycleName": "required, the cycle name, type is string",
  "CycleType": "required, the cycle type, daily, weekly, monthly, seasonal, type is string",
  "ResetMonthDay": "required, the day of reset month, type is number, optional",
  "ResetSeasonDays": "required, the day of reset season, type is number, optional",
  "ResetTimeHour": "required, the hour of reset time, type is number, optional",
  "ResetTimeMinute": "required, the minute of reset time, type is number, optional",
  "ResetWeekDay": "required, the day of reset week, type is number, optional",
  "StartDate": "required, the start date, type yyyy-MM-dd HH:mm:ss",
  "EndDate": "required, the end date, type yyyy-MM-dd HH:mm:ss",
  "Description": "optional, the description, type is string",
  "EnableEndDate": "required, the end date is enable or not, type is boolean"
}

output

{}

update-cycle

cli-load-json

{
  "CycleId": "required, the cycle id, type is string",
  "CycleName": "required, the cycle name, type is string",
  "CycleType": "required, the cycle type, daily, weekly, monthly, seasonal, type is string",
  "ResetMonthDay": "required, the day of reset month, type is number, optional",
  "ResetSeasonDays": "required, the day of reset season, type is number, optional",
  "ResetTimeHour": "required, the hour of reset time, type is number, optional",
  "ResetTimeMinute": "required, the minute of reset time, type is number, optional",
  "ResetWeekDay": "required, the day of reset week, type is number, optional",
  "StartDate": "required, the start date, type yyyy-MM-dd HH:mm:ss",
  "EndDate": "required, the end date, type yyyy-MM-dd HH:mm:ss",
  "Description": "optional, the description, type is string",
  "EnableEndDate": "required, the end date is enable or not, type is boolean"
}

output

{}

delete-cycle

cli-load-json

{
  "CycleNames": ["required, the cycle name, type is string"]
}

output

{}

Stat Interface

list-stat

cli-load-json

{
  "QueryKey": "optional, the stat name to search, type is string"
}

output

{
  "List": [
    {
      "Description": "type is string",
      "EnableMin": "use the min value, type is boolean",
      "EnableMax": "use the max value, type is boolean",
      "MaxValue": "the max value, type is number",
      "MinValue": "the min value, type is number",
      "StatName": "the stat name, type is string",
      "StatId": "the stat id, type is string"
    }
  ]
}

describe-stat

cli-load-json

{
  "StatName": "required, the stat name, type is string"
}

output

{
  "List": [
    {
      "Description": "type is string",
      "EnableMin": "use the min value, type is boolean",
      "EnableMax": "use the max value, type is boolean",
      "MaxValue": "the max value, type is number",
      "MinValue": "the min value, type is number",
      "StatName": "the stat name, type is string",
      "StatId": "the stat id, type is string"
    }
  ]
}

describe-persistent-stat-item

cli-load-json

{
  "StatName": "required, the stat name, type is string",
  "Keys": ["required, the key, type is string"]
}

output

{
  "List": [
    {
      "StatName": "the stat name, type is string",
      "Key": "the key, type is string",
      "Value": "the value of key, type is number",
      "SecondaryValue": "the secondary value of key, type is number",
      "Tags": ["the tag, type is string"],
      "AggregateType": "value: OVERRIDE | SUM | MAX | MIN, value: string"
    }
  ]
}

update-stat-key

cli-load-json

{
  "StatName": "required, the stat name, type is string",
  "Key": "required, the key, type is string",
  "Value": "required, the value of key, type is number",
  "SecondaryValue": "required, the secondary value of key, type is number",
  "Tags": ["the tag, type is string"],
  "AggregateType": "required, value: OVERRIDE | SUM | MAX | MIN, value: string"
}

output

{}

delete-stat-key

cli-load-json

{
  "StatName": "required, the stat name, type is string",
  "Keys": ["required, the key, type is string"]
}

output

{}

describe-recent-stat-items

cli-load-json

{
  "StatName": "required, the stat name, type is string"
}

output

{
  "List": [
    {
      "StatName": "the stat name, type is string",
      "Key": "the key, type is string",
      "Value": "the value of key, type is number",
      "SecondaryValue": "the secondary value of key, type is number",
      "Tags": ["the tag, type is string"],
      "AggregateType": "value: OVERRIDE | SUM | MAX | MIN, value: string"
    }
  ]
}

create-stat

cli-load-json

{
  "StatName": "required, the stat name, type is string",
  "MaxValue": "required, the max value, type is number",
  "MinValue": "required, the min value, type is number",
  "Description": "optional, type is string",
  "EnableMin": "required, use the min value, type is boolean",
  "EnableMax": "required, use the max value, type is boolean"
}

output

{}

update-stat

cli-load-json

{
  "StatId": "required, the stat id, type is string",
  "StatName": "required, the stat name, type is string",
  "MaxValue": "required, the max value, type is number",
  "MinValue": "required, the min value, type is number",
  "Description": "optional, type is string",
  "EnableMin": "required, use the min value, type is boolean",
  "EnableMax": "required, use the max value, type is boolean"
}

output

{}

delete-stat

cli-load-json

{
  "StatName": "required, the stat name, type is string"
}

output

{}

Leaderboard Interface

describe-leaderboard

cli-load-json

{
  "Offset": "the start offset of the result list, start from 0, type is number",
  "Count": "the count of the result list, max is 50, type is number"
}

output

{
  "List": [
    {
      "LeaderboardId": "the leaderboard id, type is string",
      "LeaderboardName": "the leaderboard name, type is string",
      "CycleEndTime": "the cycle end time, type is string",
      "CycleName": "the cycle name, type is string",
      "CycleStartTime": "the cycle start time, type is string",
      "Description": "type is string",
      "SecondaryValueOrder": {
        "IsUsed": "use secondary value order or not, type is boolean",
        "Order": "value:Ascending|Descending, type is string"
      },
      "StatId": "the stat id, type is string",
      "StatName": "the stat name, type is string",
      "UpdateTimeOrder": {
        "IsUsed": "use update time order or not, type is boolean",
        "Order": "value:Ascending|Descending, type is string"
      },
      "UpdatedTime": "the updated time, type is string",
      "ValueOrder": "value:Ascending|Descending, type is string"
    }
  ],
  "TotalNum": "the leaderboard count, type is number",
  "NextOffset": "the next page offset, type is number"
}

describe-leaderboard-by-name

cli-load-json

{
  "LeaderboardName": "required, the leaderboard name, type is string"
}

output

{
  "LeaderboardId": "the leaderboard id, type is string",
  "LeaderboardName": "the leaderboard name, type is string",
  "CycleEndTime": "the cycle end time, type is string",
  "CycleName": "the cycle name, type is string",
  "CycleStartTime": "the cycle start time, type is string",
  "Description": "type is string",
  "SecondaryValueOrder": {
    "IsUsed": "use secondary value order or not, type is boolean",
    "Order": "value:Ascending|Descending, type is string"
  },
  "StatId": "the stat id, type is string",
  "StatName": "the stat name, type is string",
  "UpdateTimeOrder": {
    "IsUsed": "use secondary value order or not, type is boolean",
    "Order": "value:Ascending|Descending, type is string"
  },
  "UpdatedTime": "the updated time, type is string",
  "ValueOrder": "value:Ascending|Descending, type is string"
}

list-ranking

cli-load-json

{
  "LeaderboardName": "required, the leaderboard name, type is string",
  "Offset": "the start offset of the result list, start from 0, type is number",
  "Count": "the count of the result list, max is 50, type is number"
}

output

{
  "List": [
    {
      "Rank": "the serial number of ranking, type is number",
      "Key": "type is string",
      "Value": "the value of key, type is number",
      "SecondaryValue": "the secondary value of key, type is number",
      "Tags": ["the tag, type is string"]
    }
  ],
  "TotalNum": "the count of list, type is number"
}

list-ranking-by-key

cli-load-json

{
  "LeaderboardName": "required, the leaderboard name, type is string",
  "Keys": ["required, the key, type is string"]
}

output

{
  "List": [
    {
      "Rank": "the serial number of ranking, type is number",
      "Key": "type is string",
      "Value": "the value of key, type is number",
      "SecondaryValue": "the secondary value of key, type is number",
      "Tags": ["the tag, type is string"]
    }
  ]
}

create-leaderboard

cli-load-json

{
  "LeaderboardName": "required, the leaderboard name, type is string",
  "Description": "optional, type is string",
  "StatId": "required, the stat id, type is string",
  "ValueOrder": "required, value:Ascending|Descending, type is string",
  "SecondaryValueOrder": {
    "IsUsed": "use secondary value order or not, type is boolean",
    "Order": "value:Ascending|Descending, type is string"
  },
  "UpdateTimeOrder": {
    "IsUsed": "use secondary value order or not, type is boolean",
    "Order": "value:Ascending|Descending, type is string"
  },
  "cycleName": "required, the cycle name, type is string"
}

output

{}

update-leaderboard

cli-load-json

{
  "LeaderboardName": "required, the leaderboard name, type is string",
  "Description": "optional, type is string"
}

output

{}

delete-leaderboard

cli-load-json

{
  "LeaderboardName": "required, the leaderboard name, type is string"
}

output

{}

Task Interface

list-task

cli-load-json

{}

output

{
  "List": [
    {
      "Name": "the name of the task, must be unique, type is string",
      "CronExpression": "the cron of the task, type is string",
      "TimerType": "the timer type of the task, must be `Only Run Once`, `Run Forever` or `With Deadline`, type is string",
      "Description": "the description of the task, type is string",
      "LifeTime": "the number of time if `TimerType` is `With Deadline`, type is number",
      "LifeTimeUnit": "the unit of time, must be `Seconds`,`Days` or `Years(365 days)`, type is string",
      "Actions": [
        {
          "ActionType": "the type of action, must be `Virtual Server`",
          "ActionEntity": {
            "ServerName": "the name of virtual server"
          },
          "ActionArgs": "the args of action, type is string"
        }
      ]
    }
  ]
}

describe-task

cli-load-json

{
  "Name": "required, the name of the task, must be unique, type is string"
}

output

{
  "Name": "the name of the task, must be unique, type is string",
  "CronExpression": "the cron of the task, type is string",
  "TimerType": "the timer type of the task, must be `Only Run Once`, `Run Forever` or `With Deadline`, type is string",
  "Description": "the description of the task, type is string",
  "LifeTime": "the number of time if `TimerType` is `With Deadline`, type is number",
  "LifeTimeUnit": "the unit of time, must be `Seconds`,`Days` or `Years(365 days)`, type is string",
  "Actions": [
    {
      "ActionType": "the type of action, must be `Virtual Server`",
      "ActionEntity": {
        "ServerName": "the name of virtual server"
      },
      "ActionArgs": "the args of action, type is string"
    }
  ]
}

execute-task

cli-load-json

{
  "Name": "required, the name of the task, must be unique, type is string"
}

output

{}

create-task

cli-load-json

{
  "Name": "required, the name of the task, must be unique, type is string",
  "CronExpression": "required, the cron of the task, type is string",
  "TimerType": "required, the timer type of the task, must be `Only Run Once`, `Run Forever` or `With Deadline`, type is string",
  "Description": "optional, the description of the task, type is string",
  "LifeTime": "required, the number of time if `TimerType` is `With Deadline`, type is number",
  "LifeTimeUnit": "required, the unit of time, must be `Seconds`,`Days` or `Years(365 days)`, type is string",
  "Actions": [
    {
      "ActionType": "the type of action, must be `Virtual Server`",
      "ActionEntity": {
        "ServerName": "the name of virtual server when ActionType is `Virtual Server`"
      },
      "ActionArgs": "the args of action, type is string"
    }
  ]
}

output

{}

update-task

cli-load-json

{
  "Name": "required, the name of the task, must be unique, type is string",
  "CronExpression": "required, the cron of the task, type is string",
  "TimerType": "required, the timer type of the task, must be `Only Run Once`, `Run Forever` or `With Deadline`, type is string",
  "Description": "optional, the description of the task, type is string",
  "LifeTime": "required, the number of time if `TimerType` is `With Deadline`, type is number",
  "LifeTimeUnit": "required, the unit of time, must be `Seconds`,`Days` or `Years(365 days)`, type is string",
  "Actions": [
    {
      "ActionType": "the type of action, must be `Virtual Server`",
      "ActionEntity": {
        "ServerName": "the name of virtual server when ActionType is `Virtual Server`"
      },
      "ActionArgs": "the args of action, type is string"
    }
  ]
}

output

{}

delete-task

cli-load-json

{
  "Name": "required, the name of the task, must be unique, type is string"
}

output

{}

Event Handler Interface

list-event

cli-load-json

{
  "Name": "optional, the name of the event handler, type is string"
}

output

{
  "List": [
    {
      "EventName": "the name of the event, type is string",
      "Description": "the description of the event, type is string",
      "HandlerCount": "the count of the event handler, type is number",
      "EventFields": [
        {
          "Name": "the name of field, type is string",
          "Type": "the type of field, type is string",
          "Notes": "the explain of field, type is string"
        }
      ]
    }
  ]
}

list-event-handler

cli-load-json

{
  "Event": "required, the name of the event, type is string"
}

output

{
  "List": [
    {
      "Name": "the name of Dvent Handler",
      "Description": "the description of the event handler, type is string",
      "Filters": {
        "OR": [
          {
            "AND": [
              {
                "Key": "the field of evnet data",
                "Oper": "the operator to compare with value, must be `==`,`<`,`>`,`<=`,`>=` or `!=`",
                "Type": "the type of value, must be `int`, `uint`, `int16`, `uint16`, `int32`, `uint32`, `int64`, `uint64`, `string`, `float`, `float32`, `float64`, `var`, `extra`, `bool`",
                "Value": "the value to compare"
              }
            ]
          }
        ]
      },
      "Actions": [
        {
          "ActionType": "the type of action, must be `Virtual Server` or `Webhook`",
          "ActionEntity": {
            "ServerName": "the name of virtual server",
            "WebhookName": "the name of webhook"
          },
          "ActionArgs": "the args of action, type is json"
        }
      ]
    }
  ]
}

describe-event-handler

cli-load-json

{
  "EventType": "required, the name of event, type is string",
  "Name": "required, the name of the event handler, type is string"
}

output

{
  "Name": "the name of Dvent Handler",
  "Description": "the description of the event handler, type is string",
  "Filters": {
    "OR": [
      {
        "AND": [
          {
            "Key": "the field of evnet data",
            "Oper": "the operator to compare with value, must be `==`,`<`,`>`,`<=`,`>=` or `!=`",
            "Type": "the type of value, must be `int`, `uint`, `int16`, `uint16`, `int32`, `uint32`, `int64`, `uint64`, `string`, `float`, `float32`, `float64`, `var`, `extra`, `bool`",
            "Value": "the value to compare"
          }
        ]
      }
    ]
  },
  "Actions": [
    {
      "ActionType": "the type of action, must be `Virtual Server` or `Webhook`",
      "ActionEntity": {
        "ServerName": "the name of virtual server",
        "WebhookName": "the name of webhook"
      },
      "ActionArgs": "the args of action, type is json"
    }
  ]
}

create-event-handler

cli-load-json

{
  "Name": "required, the name of the event handler, must be unique, type is string",
  "Description": "optional, the description of the event handler, type is string",
  "EventType": "required, the name of event, type is string",
  "Filters": {
    "OR": [
      {
        "AND": [
          {
            "Key": "the field of evnet data",
            "Oper": "the operator to compare with value, must be `==`,`<`,`>`,`<=`,`>=` or `!=`",
            "Type": "the type of value, must be `int`, `uint`, `int16`, `uint16`, `int32`, `uint32`, `int64`, `uint64`, `string`, `float`, `float32`, `float64`, `var`, `extra`, `bool`",
            "Value": "the value to compare"
          }
        ]
      }
    ]
  },
  "Actions": [
    {
      "ActionType": "the type of action, must be `Virtual Server` or `Webhook`",
      "ActionEntity": {
        "ServerName": "the name of virtual server when ActionType is `Virtual Server`",
        "WebhookName": "the name of webhook when ActionType is `Webhook`"
      },
      "ActionArgs": "the args of action, type is json"
    }
  ]
}

output

{}

update-event-handler

cli-load-json

{
  "Name": "required, the name of the event handler, must be unique, type is string",
  "EventType": "required, the name of event, type is string",
  "Description": "optional, the description of the event handler, type is string",
  "EventType": "required, the name of event, type is string",
  "Filters": {
    "OR": [
      {
        "AND": [
          {
            "Key": "the field of evnet data",
            "Oper": "the operator to compare with value, must be `==`,`<`,`>`,`<=`,`>=` or `!=`",
            "Type": "the type of value, must be `int`, `uint`, `int16`, `uint16`, `int32`, `uint32`, `int64`, `uint64`, `string`, `float`, `float32`, `float64`, `var`, `extra`, `bool`",
            "Value": "the value to compare"
          }
        ]
      }
    ]
  },
  "Actions": [
    {
      "ActionType": "the type of action, must be `Virtual Server` or `Webhook`",
      "ActionEntity": {
        "ServerName": "the name of virtual server when ActionType is `Virtual Server`",
        "WebhookName": "the name of webhook when ActionType is `Webhook`"
      },
      "ActionArgs": "the args of action, type is json"
    }
  ]
}

output

{}

delete-event-handler

cli-load-json

{
  "Name": "required, the name of the event handler, type is string",
  "EventType": "required, the name of event, type is string"
}

output

{}