sgw-20180511/main.tea (7,790 lines of code) (raw):
/**
*
*/
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;
extends OpenApi;
init(config: OpenApi.Config){
super(config);
@endpointRule = 'regional';
@endpointMap = {
cn-qingdao = 'sgw.cn-shanghai.aliyuncs.com',
cn-beijing = 'sgw.cn-shanghai.aliyuncs.com',
cn-chengdu = 'sgw.cn-shanghai.aliyuncs.com',
cn-zhangjiakou = 'sgw.cn-shanghai.aliyuncs.com',
cn-huhehaote = 'sgw.cn-shanghai.aliyuncs.com',
cn-hangzhou = 'sgw.cn-shanghai.aliyuncs.com',
cn-shenzhen = 'sgw.cn-shanghai.aliyuncs.com',
cn-hongkong = 'sgw.cn-shanghai.aliyuncs.com',
us-east-1 = 'sgw.us-west-1.aliyuncs.com',
};
checkConfig(config);
@endpoint = getEndpoint('sgw', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}
function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
if (!Util.empty(endpoint)) {
return endpoint;
}
if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
return endpointMap[regionId];
}
return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}
model ActivateAllInOneGatewayRequest {
clientUUID?: string(name='ClientUUID'),
deviceNumber?: string(name='DeviceNumber'),
gatewayId?: string(name='GatewayId'),
model?: string(name='Model'),
securityToken?: string(name='SecurityToken'),
serialNumber?: string(name='SerialNumber'),
}
model ActivateAllInOneGatewayResponseBody = {
code?: string(name='Code'),
gatewayId?: string(name='GatewayId'),
licenseContent?: string(name='LicenseContent'),
message?: string(name='Message'),
regionId?: string(name='RegionId'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model ActivateAllInOneGatewayResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ActivateAllInOneGatewayResponseBody(name='body'),
}
async function activateAllInOneGatewayWithOptions(request: ActivateAllInOneGatewayRequest, runtime: Util.RuntimeOptions): ActivateAllInOneGatewayResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientUUID)) {
query['ClientUUID'] = request.clientUUID;
}
if (!Util.isUnset(request.deviceNumber)) {
query['DeviceNumber'] = request.deviceNumber;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.model)) {
query['Model'] = request.model;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.serialNumber)) {
query['SerialNumber'] = request.serialNumber;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ActivateAllInOneGateway',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function activateAllInOneGateway(request: ActivateAllInOneGatewayRequest): ActivateAllInOneGatewayResponse {
var runtime = new Util.RuntimeOptions{};
return activateAllInOneGatewayWithOptions(request, runtime);
}
model ActivateGatewayRequest {
category?: string(name='Category'),
clientUUID?: string(name='ClientUUID', example='28c07861-a93b-4aa2-ae3a-3f7b7e7f6184'),
model?: string(name='Model'),
securityToken?: string(name='SecurityToken'),
serialNumber?: string(name='SerialNumber'),
token?: string(name='Token', example='xxxxxxxxxxxxxxxx'),
type?: string(name='Type'),
}
model ActivateGatewayResponseBody = {
code?: string(name='Code', example='200'),
gatewayId?: string(name='GatewayId', example='gw-1234567890abcd'),
message?: string(name='Message', example='successful'),
regionId?: string(name='RegionId', example='cn-shanghai'),
requestId?: string(name='RequestId', example='76109369-5729-467D-D4A3-1131A8DA1973'),
success?: boolean(name='Success', example='true'),
}
model ActivateGatewayResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ActivateGatewayResponseBody(name='body'),
}
async function activateGatewayWithOptions(request: ActivateGatewayRequest, runtime: Util.RuntimeOptions): ActivateGatewayResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.category)) {
query['Category'] = request.category;
}
if (!Util.isUnset(request.clientUUID)) {
query['ClientUUID'] = request.clientUUID;
}
if (!Util.isUnset(request.model)) {
query['Model'] = request.model;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.serialNumber)) {
query['SerialNumber'] = request.serialNumber;
}
if (!Util.isUnset(request.token)) {
query['Token'] = request.token;
}
if (!Util.isUnset(request.type)) {
query['Type'] = request.type;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ActivateGateway',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function activateGateway(request: ActivateGatewayRequest): ActivateGatewayResponse {
var runtime = new Util.RuntimeOptions{};
return activateGatewayWithOptions(request, runtime);
}
model AddSharesToExpressSyncRequest {
expressSyncId?: string(name='ExpressSyncId', example='sync-0001xv7je357xn8tr***'),
gatewayShares?: string(name='GatewayShares', example='{"gw-000gwgp0j3jp8cb3t***":"share1,share2","gw-0001b2otnkdzte62j***":"weekly"}'),
securityToken?: string(name='SecurityToken'),
}
model AddSharesToExpressSyncResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
mnsFullSyncDelay?: long(name='MnsFullSyncDelay'),
mnsInnerEndpoint?: string(name='MnsInnerEndpoint'),
mnsPublicEndpoint?: string(name='MnsPublicEndpoint'),
mnsQueues?: string(name='MnsQueues'),
mnsTopic?: string(name='MnsTopic'),
requestId?: string(name='RequestId', example='1EDBC004-6B1C-4511-ACF5-0B4875BA3887'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0001xv7je357xr6ql***'),
}
model AddSharesToExpressSyncResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: AddSharesToExpressSyncResponseBody(name='body'),
}
async function addSharesToExpressSyncWithOptions(request: AddSharesToExpressSyncRequest, runtime: Util.RuntimeOptions): AddSharesToExpressSyncResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.expressSyncId)) {
query['ExpressSyncId'] = request.expressSyncId;
}
if (!Util.isUnset(request.gatewayShares)) {
query['GatewayShares'] = request.gatewayShares;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'AddSharesToExpressSync',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function addSharesToExpressSync(request: AddSharesToExpressSyncRequest): AddSharesToExpressSyncResponse {
var runtime = new Util.RuntimeOptions{};
return addSharesToExpressSyncWithOptions(request, runtime);
}
model AddTagsToGatewayRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
tags?: string(name='Tags'),
}
model AddTagsToGatewayResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model AddTagsToGatewayResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: AddTagsToGatewayResponseBody(name='body'),
}
async function addTagsToGatewayWithOptions(request: AddTagsToGatewayRequest, runtime: Util.RuntimeOptions): AddTagsToGatewayResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.tags)) {
query['Tags'] = request.tags;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'AddTagsToGateway',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function addTagsToGateway(request: AddTagsToGatewayRequest): AddTagsToGatewayResponse {
var runtime = new Util.RuntimeOptions{};
return addTagsToGatewayWithOptions(request, runtime);
}
model CheckActivationKeyRequest {
cryptKey?: string(name='CryptKey'),
cryptText?: string(name='CryptText'),
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
token?: string(name='Token'),
}
model CheckActivationKeyResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model CheckActivationKeyResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CheckActivationKeyResponseBody(name='body'),
}
async function checkActivationKeyWithOptions(request: CheckActivationKeyRequest, runtime: Util.RuntimeOptions): CheckActivationKeyResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.cryptKey)) {
query['CryptKey'] = request.cryptKey;
}
if (!Util.isUnset(request.cryptText)) {
query['CryptText'] = request.cryptText;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.token)) {
query['Token'] = request.token;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CheckActivationKey',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function checkActivationKey(request: CheckActivationKeyRequest): CheckActivationKeyResponse {
var runtime = new Util.RuntimeOptions{};
return checkActivationKeyWithOptions(request, runtime);
}
model CheckBlockVolumeNameRequest {
bucketEndpoint?: string(name='BucketEndpoint', description='Bucket Endpoint。', example='oss-cn-hangzhou-internal.aliyuncs.com'),
bucketName?: string(name='BucketName', example='random***'),
securityToken?: string(name='SecurityToken'),
volumeName?: string(name='VolumeName', example='alex***'),
}
model CheckBlockVolumeNameResponseBody = {
code?: string(name='Code', example='200'),
isAlreadyExist?: boolean(name='IsAlreadyExist'),
isRequireRecovery?: string(name='IsRequireRecovery', example='false'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='735B642E-6564-4A87-99A0-3609F67C787E'),
success?: boolean(name='Success', example='true'),
}
model CheckBlockVolumeNameResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CheckBlockVolumeNameResponseBody(name='body'),
}
async function checkBlockVolumeNameWithOptions(request: CheckBlockVolumeNameRequest, runtime: Util.RuntimeOptions): CheckBlockVolumeNameResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bucketEndpoint)) {
query['BucketEndpoint'] = request.bucketEndpoint;
}
if (!Util.isUnset(request.bucketName)) {
query['BucketName'] = request.bucketName;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.volumeName)) {
query['VolumeName'] = request.volumeName;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CheckBlockVolumeName',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function checkBlockVolumeName(request: CheckBlockVolumeNameRequest): CheckBlockVolumeNameResponse {
var runtime = new Util.RuntimeOptions{};
return checkBlockVolumeNameWithOptions(request, runtime);
}
model CheckGatewayEssdSupportRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model CheckGatewayEssdSupportResponseBody = {
code?: string(name='Code'),
isServiceAffect?: boolean(name='IsServiceAffect'),
isSupportEssd?: boolean(name='IsSupportEssd'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model CheckGatewayEssdSupportResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CheckGatewayEssdSupportResponseBody(name='body'),
}
async function checkGatewayEssdSupportWithOptions(request: CheckGatewayEssdSupportRequest, runtime: Util.RuntimeOptions): CheckGatewayEssdSupportResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CheckGatewayEssdSupport',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function checkGatewayEssdSupport(request: CheckGatewayEssdSupportRequest): CheckGatewayEssdSupportResponse {
var runtime = new Util.RuntimeOptions{};
return checkGatewayEssdSupportWithOptions(request, runtime);
}
model CheckMnsServiceRequest {
securityToken?: string(name='SecurityToken'),
}
model CheckMnsServiceResponseBody = {
checkMessage?: string(name='CheckMessage'),
code?: string(name='Code'),
isEnabled?: boolean(name='IsEnabled'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model CheckMnsServiceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CheckMnsServiceResponseBody(name='body'),
}
async function checkMnsServiceWithOptions(request: CheckMnsServiceRequest, runtime: Util.RuntimeOptions): CheckMnsServiceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CheckMnsService',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function checkMnsService(request: CheckMnsServiceRequest): CheckMnsServiceResponse {
var runtime = new Util.RuntimeOptions{};
return checkMnsServiceWithOptions(request, runtime);
}
model CheckRoleRequest {
roleType?: string(name='RoleType'),
securityToken?: string(name='SecurityToken'),
}
model CheckRoleResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model CheckRoleResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CheckRoleResponseBody(name='body'),
}
async function checkRoleWithOptions(request: CheckRoleRequest, runtime: Util.RuntimeOptions): CheckRoleResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.roleType)) {
query['RoleType'] = request.roleType;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CheckRole',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function checkRole(request: CheckRoleRequest): CheckRoleResponse {
var runtime = new Util.RuntimeOptions{};
return checkRoleWithOptions(request, runtime);
}
model CheckSlrRoleRequest {
createIfNotExist?: boolean(name='CreateIfNotExist'),
roleName?: string(name='RoleName'),
securityToken?: string(name='SecurityToken'),
}
model CheckSlrRoleResponseBody = {
code?: string(name='Code'),
exist?: boolean(name='Exist'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
requireOldWayCheck?: boolean(name='RequireOldWayCheck'),
success?: boolean(name='Success'),
}
model CheckSlrRoleResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CheckSlrRoleResponseBody(name='body'),
}
async function checkSlrRoleWithOptions(request: CheckSlrRoleRequest, runtime: Util.RuntimeOptions): CheckSlrRoleResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.createIfNotExist)) {
query['CreateIfNotExist'] = request.createIfNotExist;
}
if (!Util.isUnset(request.roleName)) {
query['RoleName'] = request.roleName;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CheckSlrRole',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function checkSlrRole(request: CheckSlrRoleRequest): CheckSlrRoleResponse {
var runtime = new Util.RuntimeOptions{};
return checkSlrRoleWithOptions(request, runtime);
}
model CheckUpgradeVersionRequest {
clientUUID?: string(name='ClientUUID'),
gatewayId?: string(name='GatewayId'),
gatewayVersion?: string(name='GatewayVersion'),
securityToken?: string(name='SecurityToken'),
}
model CheckUpgradeVersionResponseBody = {
code?: string(name='Code'),
latestVersion?: string(name='LatestVersion'),
message?: string(name='Message'),
option?: string(name='Option'),
patches?: {
patch?: [
{
internalUrl?: string(name='InternalUrl'),
MD5?: string(name='MD5'),
name?: string(name='Name'),
url?: string(name='Url'),
}
](name='Patch')
}(name='Patches'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model CheckUpgradeVersionResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CheckUpgradeVersionResponseBody(name='body'),
}
async function checkUpgradeVersionWithOptions(request: CheckUpgradeVersionRequest, runtime: Util.RuntimeOptions): CheckUpgradeVersionResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientUUID)) {
query['ClientUUID'] = request.clientUUID;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.gatewayVersion)) {
query['GatewayVersion'] = request.gatewayVersion;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CheckUpgradeVersion',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function checkUpgradeVersion(request: CheckUpgradeVersionRequest): CheckUpgradeVersionResponse {
var runtime = new Util.RuntimeOptions{};
return checkUpgradeVersionWithOptions(request, runtime);
}
model CreateCacheRequest {
category?: string(name='Category'),
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
sizeInGB?: long(name='SizeInGB'),
}
model CreateCacheResponseBody = {
buyURL?: string(name='BuyURL'),
cacheId?: string(name='CacheId'),
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model CreateCacheResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateCacheResponseBody(name='body'),
}
async function createCacheWithOptions(request: CreateCacheRequest, runtime: Util.RuntimeOptions): CreateCacheResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.category)) {
query['Category'] = request.category;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.sizeInGB)) {
query['SizeInGB'] = request.sizeInGB;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateCache',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function createCache(request: CreateCacheRequest): CreateCacheResponse {
var runtime = new Util.RuntimeOptions{};
return createCacheWithOptions(request, runtime);
}
model CreateElasticGatewayPrivateZoneRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model CreateElasticGatewayPrivateZoneResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model CreateElasticGatewayPrivateZoneResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateElasticGatewayPrivateZoneResponseBody(name='body'),
}
async function createElasticGatewayPrivateZoneWithOptions(request: CreateElasticGatewayPrivateZoneRequest, runtime: Util.RuntimeOptions): CreateElasticGatewayPrivateZoneResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateElasticGatewayPrivateZone',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function createElasticGatewayPrivateZone(request: CreateElasticGatewayPrivateZoneRequest): CreateElasticGatewayPrivateZoneResponse {
var runtime = new Util.RuntimeOptions{};
return createElasticGatewayPrivateZoneWithOptions(request, runtime);
}
model CreateExpressSyncRequest {
bucketName?: string(name='BucketName', example='sgw-test***'),
bucketPrefix?: string(name='BucketPrefix', example='test***'),
bucketRegion?: string(name='BucketRegion', example='cn-hangzhou'),
description?: string(name='Description'),
name?: string(name='Name', example='alex-tb***'),
securityToken?: string(name='SecurityToken'),
}
model CreateExpressSyncResponseBody = {
code?: string(name='Code', example='200'),
expressSyncId?: string(name='ExpressSyncId', example='sync-0001xv7je357xn8tr***'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='EEFC9927-B097-446D-8FDA-F848C8B2C9E0'),
success?: boolean(name='Success', example='true'),
}
model CreateExpressSyncResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateExpressSyncResponseBody(name='body'),
}
async function createExpressSyncWithOptions(request: CreateExpressSyncRequest, runtime: Util.RuntimeOptions): CreateExpressSyncResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bucketName)) {
query['BucketName'] = request.bucketName;
}
if (!Util.isUnset(request.bucketPrefix)) {
query['BucketPrefix'] = request.bucketPrefix;
}
if (!Util.isUnset(request.bucketRegion)) {
query['BucketRegion'] = request.bucketRegion;
}
if (!Util.isUnset(request.description)) {
query['Description'] = request.description;
}
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateExpressSync',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function createExpressSync(request: CreateExpressSyncRequest): CreateExpressSyncResponse {
var runtime = new Util.RuntimeOptions{};
return createExpressSyncWithOptions(request, runtime);
}
model CreateGatewayRequest {
description?: string(name='Description'),
gatewayClass?: string(name='GatewayClass', example='Basic'),
location?: string(name='Location', example='Cloud'),
name?: string(name='Name', example='alex***'),
postPaid?: boolean(name='PostPaid', example='true'),
publicNetworkBandwidth?: int32(name='PublicNetworkBandwidth', example='50'),
releaseAfterExpiration?: boolean(name='ReleaseAfterExpiration', example='true'),
resourceRegionId?: string(name='ResourceRegionId', example='cn-hangzhou'),
secondaryVSwitchId?: string(name='SecondaryVSwitchId'),
securityToken?: string(name='SecurityToken'),
storageBundleId?: string(name='StorageBundleId', example='sb-0001b2otnkdxrigeq***'),
type?: string(name='Type', example='File'),
untrustedEnvId?: string(name='UntrustedEnvId'),
untrustedEnvInstanceType?: string(name='UntrustedEnvInstanceType'),
vSwitchId?: string(name='VSwitchId', example='vsw-bp1krhkglx3nahkb9s***'),
}
model CreateGatewayResponseBody = {
buyURL?: string(name='BuyURL', example='https://common-buy.aliyun.com/?commodityCode=hcs_sgw_csg_pre&request={"gateway_id":"gw-0007va9bnidei3s8a***","directBuy":"false","gateway_class":"standard","cache_cloud_efficiency_size":0}®ionId=cn-hangzhou#/buy'),
code?: string(name='Code', example='200'),
gatewayId?: string(name='GatewayId', example='gw-0001xv7je357zm9u6***'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='8E69E1A1-9076-4C8C-8ADF-ACD253886E22'),
success?: boolean(name='Success', example='true'),
}
model CreateGatewayResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateGatewayResponseBody(name='body'),
}
async function createGatewayWithOptions(request: CreateGatewayRequest, runtime: Util.RuntimeOptions): CreateGatewayResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.description)) {
query['Description'] = request.description;
}
if (!Util.isUnset(request.gatewayClass)) {
query['GatewayClass'] = request.gatewayClass;
}
if (!Util.isUnset(request.location)) {
query['Location'] = request.location;
}
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.postPaid)) {
query['PostPaid'] = request.postPaid;
}
if (!Util.isUnset(request.publicNetworkBandwidth)) {
query['PublicNetworkBandwidth'] = request.publicNetworkBandwidth;
}
if (!Util.isUnset(request.releaseAfterExpiration)) {
query['ReleaseAfterExpiration'] = request.releaseAfterExpiration;
}
if (!Util.isUnset(request.resourceRegionId)) {
query['ResourceRegionId'] = request.resourceRegionId;
}
if (!Util.isUnset(request.secondaryVSwitchId)) {
query['SecondaryVSwitchId'] = request.secondaryVSwitchId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.storageBundleId)) {
query['StorageBundleId'] = request.storageBundleId;
}
if (!Util.isUnset(request.type)) {
query['Type'] = request.type;
}
if (!Util.isUnset(request.untrustedEnvId)) {
query['UntrustedEnvId'] = request.untrustedEnvId;
}
if (!Util.isUnset(request.untrustedEnvInstanceType)) {
query['UntrustedEnvInstanceType'] = request.untrustedEnvInstanceType;
}
if (!Util.isUnset(request.vSwitchId)) {
query['VSwitchId'] = request.vSwitchId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateGateway',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function createGateway(request: CreateGatewayRequest): CreateGatewayResponse {
var runtime = new Util.RuntimeOptions{};
return createGatewayWithOptions(request, runtime);
}
model CreateGatewayBlockVolumeRequest {
cacheMode?: string(name='CacheMode', example='Cache'),
chapEnabled?: boolean(name='ChapEnabled', example='false'),
chapInPassword?: string(name='ChapInPassword', example='chapInPassword'),
chapInUser?: string(name='ChapInUser', example='chapInUser'),
chunkSize?: int32(name='ChunkSize', example='32768'),
gatewayId?: string(name='GatewayId', example='gw-000dt67z4ijngqvh1***'),
localFilePath?: string(name='LocalFilePath', example='/dev/vdb'),
name?: string(name='Name', example='name'),
ossBucketName?: string(name='OssBucketName', example='bucketName'),
ossBucketSsl?: boolean(name='OssBucketSsl', example='true'),
ossEndpoint?: string(name='OssEndpoint', example='oss-cn-shanghai-internal.aliyuncs.com'),
recovery?: boolean(name='Recovery', example='false'),
securityToken?: string(name='SecurityToken'),
size?: long(name='Size', example='100'),
volumeProtocol?: string(name='VolumeProtocol', example='iSCSI'),
}
model CreateGatewayBlockVolumeResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='9083F167-95B1-4B40-B2CD-70DE068EC3**'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000c6hshwukkbtxrb***'),
}
model CreateGatewayBlockVolumeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateGatewayBlockVolumeResponseBody(name='body'),
}
async function createGatewayBlockVolumeWithOptions(request: CreateGatewayBlockVolumeRequest, runtime: Util.RuntimeOptions): CreateGatewayBlockVolumeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.cacheMode)) {
query['CacheMode'] = request.cacheMode;
}
if (!Util.isUnset(request.chapEnabled)) {
query['ChapEnabled'] = request.chapEnabled;
}
if (!Util.isUnset(request.chapInPassword)) {
query['ChapInPassword'] = request.chapInPassword;
}
if (!Util.isUnset(request.chapInUser)) {
query['ChapInUser'] = request.chapInUser;
}
if (!Util.isUnset(request.chunkSize)) {
query['ChunkSize'] = request.chunkSize;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.localFilePath)) {
query['LocalFilePath'] = request.localFilePath;
}
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.ossBucketName)) {
query['OssBucketName'] = request.ossBucketName;
}
if (!Util.isUnset(request.ossBucketSsl)) {
query['OssBucketSsl'] = request.ossBucketSsl;
}
if (!Util.isUnset(request.ossEndpoint)) {
query['OssEndpoint'] = request.ossEndpoint;
}
if (!Util.isUnset(request.recovery)) {
query['Recovery'] = request.recovery;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.size)) {
query['Size'] = request.size;
}
if (!Util.isUnset(request.volumeProtocol)) {
query['VolumeProtocol'] = request.volumeProtocol;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateGatewayBlockVolume',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function createGatewayBlockVolume(request: CreateGatewayBlockVolumeRequest): CreateGatewayBlockVolumeResponse {
var runtime = new Util.RuntimeOptions{};
return createGatewayBlockVolumeWithOptions(request, runtime);
}
model CreateGatewayCacheDiskRequest {
cacheDiskCategory?: string(name='CacheDiskCategory', example='cloud_efficiency'),
cacheDiskSizeInGB?: long(name='CacheDiskSizeInGB', example='60'),
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
performanceLevel?: string(name='PerformanceLevel'),
securityToken?: string(name='SecurityToken'),
}
model CreateGatewayCacheDiskResponseBody = {
buyURL?: string(name='BuyURL', example='https://common-buy.aliyun.com/?commodityCode=hcs_sgw_csg_pre&request={"gateway_id":"gw-0007va9bnidei3s8a***","directBuy":"false","gateway_class":"standard","cache_cloud_efficiency_size":0}®ionId=cn-hangzhou#/buy'),
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='8E69E1A1-9076-4C8C-8ADF-ACD253886E22'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0001xv7je357xv4st***'),
}
model CreateGatewayCacheDiskResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateGatewayCacheDiskResponseBody(name='body'),
}
async function createGatewayCacheDiskWithOptions(request: CreateGatewayCacheDiskRequest, runtime: Util.RuntimeOptions): CreateGatewayCacheDiskResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.cacheDiskCategory)) {
query['CacheDiskCategory'] = request.cacheDiskCategory;
}
if (!Util.isUnset(request.cacheDiskSizeInGB)) {
query['CacheDiskSizeInGB'] = request.cacheDiskSizeInGB;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.performanceLevel)) {
query['PerformanceLevel'] = request.performanceLevel;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateGatewayCacheDisk',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function createGatewayCacheDisk(request: CreateGatewayCacheDiskRequest): CreateGatewayCacheDiskResponse {
var runtime = new Util.RuntimeOptions{};
return createGatewayCacheDiskWithOptions(request, runtime);
}
model CreateGatewayFileShareRequest {
accessBasedEnumeration?: boolean(name='AccessBasedEnumeration', example='false'),
backendLimit?: int32(name='BackendLimit', example='1234'),
browsable?: boolean(name='Browsable', example='true'),
bypassCacheRead?: boolean(name='BypassCacheRead', example='false'),
cacheMode?: string(name='CacheMode', example='Cache'),
clientSideCmk?: string(name='ClientSideCmk', example='xxxxx'),
clientSideEncryption?: boolean(name='ClientSideEncryption', example='false'),
directIO?: boolean(name='DirectIO', example='false'),
downloadLimit?: int32(name='DownloadLimit', example='0'),
fastReclaim?: boolean(name='FastReclaim', example='false'),
frontendLimit?: int32(name='FrontendLimit', example='1234'),
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
ignoreDelete?: boolean(name='IgnoreDelete', example='false'),
inPlace?: boolean(name='InPlace', example='false'),
kmsRotatePeriod?: long(name='KmsRotatePeriod', example='0'),
lagPeriod?: long(name='LagPeriod', example='5'),
localFilePath?: string(name='LocalFilePath', example='/dev/vdb'),
name?: string(name='Name', example='alex***'),
nfsV4Optimization?: boolean(name='NfsV4Optimization', example='false'),
ossBucketName?: string(name='OssBucketName', example='testbucket'),
ossBucketSsl?: boolean(name='OssBucketSsl', example='true'),
ossEndpoint?: string(name='OssEndpoint', example='oss-cn-hangzhou-internal.aliyuncs.com'),
partialSyncPaths?: string(name='PartialSyncPaths', example='test1'),
pathPrefix?: string(name='PathPrefix', example='test1'),
pollingInterval?: int32(name='PollingInterval', example='4500'),
readOnlyClientList?: string(name='ReadOnlyClientList', example='12.12.12.12'),
readOnlyUserList?: string(name='ReadOnlyUserList', example='userA,userB'),
readWriteClientList?: string(name='ReadWriteClientList', example='12.12.12.12'),
readWriteUserList?: string(name='ReadWriteUserList', example='user1,user2'),
remoteSync?: boolean(name='RemoteSync', example='false'),
remoteSyncDownload?: boolean(name='RemoteSyncDownload', example='false'),
securityToken?: string(name='SecurityToken'),
serverSideAlgorithm?: string(name='ServerSideAlgorithm', example='AES256'),
serverSideCmk?: string(name='ServerSideCmk', example='xxxxx'),
serverSideEncryption?: boolean(name='ServerSideEncryption', example='false'),
shareProtocol?: string(name='ShareProtocol', example='NFS'),
squash?: string(name='Squash', example='none'),
supportArchive?: boolean(name='SupportArchive', example='false'),
transferAcceleration?: boolean(name='TransferAcceleration', example='false'),
windowsAcl?: boolean(name='WindowsAcl', example='false'),
}
model CreateGatewayFileShareResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='F8B59F29-453D-49BF-8673-EEB8F9F2D5C6'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000eg44nmxbsh3qk***'),
}
model CreateGatewayFileShareResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateGatewayFileShareResponseBody(name='body'),
}
async function createGatewayFileShareWithOptions(request: CreateGatewayFileShareRequest, runtime: Util.RuntimeOptions): CreateGatewayFileShareResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.accessBasedEnumeration)) {
query['AccessBasedEnumeration'] = request.accessBasedEnumeration;
}
if (!Util.isUnset(request.backendLimit)) {
query['BackendLimit'] = request.backendLimit;
}
if (!Util.isUnset(request.browsable)) {
query['Browsable'] = request.browsable;
}
if (!Util.isUnset(request.bypassCacheRead)) {
query['BypassCacheRead'] = request.bypassCacheRead;
}
if (!Util.isUnset(request.cacheMode)) {
query['CacheMode'] = request.cacheMode;
}
if (!Util.isUnset(request.clientSideCmk)) {
query['ClientSideCmk'] = request.clientSideCmk;
}
if (!Util.isUnset(request.clientSideEncryption)) {
query['ClientSideEncryption'] = request.clientSideEncryption;
}
if (!Util.isUnset(request.directIO)) {
query['DirectIO'] = request.directIO;
}
if (!Util.isUnset(request.downloadLimit)) {
query['DownloadLimit'] = request.downloadLimit;
}
if (!Util.isUnset(request.fastReclaim)) {
query['FastReclaim'] = request.fastReclaim;
}
if (!Util.isUnset(request.frontendLimit)) {
query['FrontendLimit'] = request.frontendLimit;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.ignoreDelete)) {
query['IgnoreDelete'] = request.ignoreDelete;
}
if (!Util.isUnset(request.inPlace)) {
query['InPlace'] = request.inPlace;
}
if (!Util.isUnset(request.kmsRotatePeriod)) {
query['KmsRotatePeriod'] = request.kmsRotatePeriod;
}
if (!Util.isUnset(request.lagPeriod)) {
query['LagPeriod'] = request.lagPeriod;
}
if (!Util.isUnset(request.localFilePath)) {
query['LocalFilePath'] = request.localFilePath;
}
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.nfsV4Optimization)) {
query['NfsV4Optimization'] = request.nfsV4Optimization;
}
if (!Util.isUnset(request.ossBucketName)) {
query['OssBucketName'] = request.ossBucketName;
}
if (!Util.isUnset(request.ossBucketSsl)) {
query['OssBucketSsl'] = request.ossBucketSsl;
}
if (!Util.isUnset(request.ossEndpoint)) {
query['OssEndpoint'] = request.ossEndpoint;
}
if (!Util.isUnset(request.partialSyncPaths)) {
query['PartialSyncPaths'] = request.partialSyncPaths;
}
if (!Util.isUnset(request.pathPrefix)) {
query['PathPrefix'] = request.pathPrefix;
}
if (!Util.isUnset(request.pollingInterval)) {
query['PollingInterval'] = request.pollingInterval;
}
if (!Util.isUnset(request.readOnlyClientList)) {
query['ReadOnlyClientList'] = request.readOnlyClientList;
}
if (!Util.isUnset(request.readOnlyUserList)) {
query['ReadOnlyUserList'] = request.readOnlyUserList;
}
if (!Util.isUnset(request.readWriteClientList)) {
query['ReadWriteClientList'] = request.readWriteClientList;
}
if (!Util.isUnset(request.readWriteUserList)) {
query['ReadWriteUserList'] = request.readWriteUserList;
}
if (!Util.isUnset(request.remoteSync)) {
query['RemoteSync'] = request.remoteSync;
}
if (!Util.isUnset(request.remoteSyncDownload)) {
query['RemoteSyncDownload'] = request.remoteSyncDownload;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.serverSideAlgorithm)) {
query['ServerSideAlgorithm'] = request.serverSideAlgorithm;
}
if (!Util.isUnset(request.serverSideCmk)) {
query['ServerSideCmk'] = request.serverSideCmk;
}
if (!Util.isUnset(request.serverSideEncryption)) {
query['ServerSideEncryption'] = request.serverSideEncryption;
}
if (!Util.isUnset(request.shareProtocol)) {
query['ShareProtocol'] = request.shareProtocol;
}
if (!Util.isUnset(request.squash)) {
query['Squash'] = request.squash;
}
if (!Util.isUnset(request.supportArchive)) {
query['SupportArchive'] = request.supportArchive;
}
if (!Util.isUnset(request.transferAcceleration)) {
query['TransferAcceleration'] = request.transferAcceleration;
}
if (!Util.isUnset(request.windowsAcl)) {
query['WindowsAcl'] = request.windowsAcl;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateGatewayFileShare',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function createGatewayFileShare(request: CreateGatewayFileShareRequest): CreateGatewayFileShareResponse {
var runtime = new Util.RuntimeOptions{};
return createGatewayFileShareWithOptions(request, runtime);
}
model CreateGatewayLoggingRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
securityToken?: string(name='SecurityToken'),
slsLogstore?: string(name='SlsLogstore', example='logs***'),
slsProject?: string(name='SlsProject', example='alex***'),
}
model CreateGatewayLoggingResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='76109369-5729-467D-D4A3-1131A8DA19XX'),
success?: boolean(name='Success', example='true'),
}
model CreateGatewayLoggingResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateGatewayLoggingResponseBody(name='body'),
}
async function createGatewayLoggingWithOptions(request: CreateGatewayLoggingRequest, runtime: Util.RuntimeOptions): CreateGatewayLoggingResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.slsLogstore)) {
query['SlsLogstore'] = request.slsLogstore;
}
if (!Util.isUnset(request.slsProject)) {
query['SlsProject'] = request.slsProject;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateGatewayLogging',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function createGatewayLogging(request: CreateGatewayLoggingRequest): CreateGatewayLoggingResponse {
var runtime = new Util.RuntimeOptions{};
return createGatewayLoggingWithOptions(request, runtime);
}
model CreateGatewaySMBUserRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq2**'),
password?: string(name='Password', example='123***'),
securityToken?: string(name='SecurityToken'),
username?: string(name='Username', example='alex'),
}
model CreateGatewaySMBUserResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='9083F167-95B1-4B40-B2CD-70DE068EC3**'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000c6hshwukkbtxrb***'),
}
model CreateGatewaySMBUserResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateGatewaySMBUserResponseBody(name='body'),
}
async function createGatewaySMBUserWithOptions(request: CreateGatewaySMBUserRequest, runtime: Util.RuntimeOptions): CreateGatewaySMBUserResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.password)) {
query['Password'] = request.password;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.username)) {
query['Username'] = request.username;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateGatewaySMBUser',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function createGatewaySMBUser(request: CreateGatewaySMBUserRequest): CreateGatewaySMBUserResponse {
var runtime = new Util.RuntimeOptions{};
return createGatewaySMBUserWithOptions(request, runtime);
}
model CreateStorageBundleRequest {
backendBucketRegionId?: string(name='BackendBucketRegionId', example='cn-shanghai'),
description?: string(name='Description'),
name?: string(name='Name', example='alex-123***'),
securityToken?: string(name='SecurityToken'),
}
model CreateStorageBundleResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='2AD80BDC-E05C-4A77-BBAD-5EDAEDE6D333'),
storageBundleId?: string(name='StorageBundleId', example='sb-000ibk4xrlr03qrjr***'),
success?: boolean(name='Success', example='true'),
}
model CreateStorageBundleResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: CreateStorageBundleResponseBody(name='body'),
}
async function createStorageBundleWithOptions(request: CreateStorageBundleRequest, runtime: Util.RuntimeOptions): CreateStorageBundleResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.backendBucketRegionId)) {
query['BackendBucketRegionId'] = request.backendBucketRegionId;
}
if (!Util.isUnset(request.description)) {
query['Description'] = request.description;
}
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'CreateStorageBundle',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function createStorageBundle(request: CreateStorageBundleRequest): CreateStorageBundleResponse {
var runtime = new Util.RuntimeOptions{};
return createStorageBundleWithOptions(request, runtime);
}
model DeleteCSGClientsRequest {
clientIds?: [ string ](name='ClientIds'),
clientRegionId?: string(name='ClientRegionId'),
securityToken?: string(name='SecurityToken'),
}
model DeleteCSGClientsShrinkRequest {
clientIdsShrink?: string(name='ClientIds'),
clientRegionId?: string(name='ClientRegionId'),
securityToken?: string(name='SecurityToken'),
}
model DeleteCSGClientsResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model DeleteCSGClientsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteCSGClientsResponseBody(name='body'),
}
async function deleteCSGClientsWithOptions(tmpReq: DeleteCSGClientsRequest, runtime: Util.RuntimeOptions): DeleteCSGClientsResponse {
Util.validateModel(tmpReq);
var request = new DeleteCSGClientsShrinkRequest{};
OpenApiUtil.convert(tmpReq, request);
if (!Util.isUnset(tmpReq.clientIds)) {
request.clientIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.clientIds, 'ClientIds', 'json');
}
var query = {};
if (!Util.isUnset(request.clientIdsShrink)) {
query['ClientIds'] = request.clientIdsShrink;
}
if (!Util.isUnset(request.clientRegionId)) {
query['ClientRegionId'] = request.clientRegionId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteCSGClients',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deleteCSGClients(request: DeleteCSGClientsRequest): DeleteCSGClientsResponse {
var runtime = new Util.RuntimeOptions{};
return deleteCSGClientsWithOptions(request, runtime);
}
model DeleteElasticGatewayPrivateZoneRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model DeleteElasticGatewayPrivateZoneResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model DeleteElasticGatewayPrivateZoneResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteElasticGatewayPrivateZoneResponseBody(name='body'),
}
async function deleteElasticGatewayPrivateZoneWithOptions(request: DeleteElasticGatewayPrivateZoneRequest, runtime: Util.RuntimeOptions): DeleteElasticGatewayPrivateZoneResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteElasticGatewayPrivateZone',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deleteElasticGatewayPrivateZone(request: DeleteElasticGatewayPrivateZoneRequest): DeleteElasticGatewayPrivateZoneResponse {
var runtime = new Util.RuntimeOptions{};
return deleteElasticGatewayPrivateZoneWithOptions(request, runtime);
}
model DeleteExpressSyncRequest {
expressSyncId?: string(name='ExpressSyncId', example='sync-0001xv7je357xn8tr***'),
securityToken?: string(name='SecurityToken'),
}
model DeleteExpressSyncResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='A870C702-C3AC-4FC9-91E4-053D3E599A24'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0001xv7je357xv4st***'),
}
model DeleteExpressSyncResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteExpressSyncResponseBody(name='body'),
}
async function deleteExpressSyncWithOptions(request: DeleteExpressSyncRequest, runtime: Util.RuntimeOptions): DeleteExpressSyncResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.expressSyncId)) {
query['ExpressSyncId'] = request.expressSyncId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteExpressSync',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deleteExpressSync(request: DeleteExpressSyncRequest): DeleteExpressSyncResponse {
var runtime = new Util.RuntimeOptions{};
return deleteExpressSyncWithOptions(request, runtime);
}
model DeleteGatewayRequest {
gatewayId?: string(name='GatewayId', example='gw-0001xv7je3580031y***'),
reasonDetail?: string(name='ReasonDetail', example='""'),
reasonType?: string(name='ReasonType', example='REASON2'),
securityToken?: string(name='SecurityToken'),
}
model DeleteGatewayResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='151BB31D-571D-4BB9-9A02-D4210E5BF5DB'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0000iwdggbhaordhk***'),
}
model DeleteGatewayResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteGatewayResponseBody(name='body'),
}
async function deleteGatewayWithOptions(request: DeleteGatewayRequest, runtime: Util.RuntimeOptions): DeleteGatewayResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.reasonDetail)) {
query['ReasonDetail'] = request.reasonDetail;
}
if (!Util.isUnset(request.reasonType)) {
query['ReasonType'] = request.reasonType;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteGateway',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deleteGateway(request: DeleteGatewayRequest): DeleteGatewayResponse {
var runtime = new Util.RuntimeOptions{};
return deleteGatewayWithOptions(request, runtime);
}
model DeleteGatewayBlockVolumesRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwb***'),
indexId?: string(name='IndexId', example='NFSalex-gx***'),
isSourceDeletion?: boolean(name='IsSourceDeletion', example='true'),
securityToken?: string(name='SecurityToken'),
}
model DeleteGatewayBlockVolumesResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successsful'),
requestId?: string(name='RequestId', example='151BB31D-571D-4BB9-9A02-D4210E5BF5DB'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0000iwdggbhaordhk***'),
}
model DeleteGatewayBlockVolumesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteGatewayBlockVolumesResponseBody(name='body'),
}
async function deleteGatewayBlockVolumesWithOptions(request: DeleteGatewayBlockVolumesRequest, runtime: Util.RuntimeOptions): DeleteGatewayBlockVolumesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.isSourceDeletion)) {
query['IsSourceDeletion'] = request.isSourceDeletion;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteGatewayBlockVolumes',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deleteGatewayBlockVolumes(request: DeleteGatewayBlockVolumesRequest): DeleteGatewayBlockVolumesResponse {
var runtime = new Util.RuntimeOptions{};
return deleteGatewayBlockVolumesWithOptions(request, runtime);
}
model DeleteGatewayCacheDiskRequest {
cacheId?: string(name='CacheId', example='d-bp1dcnq8zldree6ok***'),
gatewayId?: string(name='GatewayId', example='gw-0001xv7je3580031y***'),
localFilePath?: string(name='LocalFilePath', example='/dev/vdb'),
securityToken?: string(name='SecurityToken'),
}
model DeleteGatewayCacheDiskResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='EEFC9927-B097-446D-8FDA-F848C8B2C9E3'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0001xv7je357xv4s***'),
}
model DeleteGatewayCacheDiskResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteGatewayCacheDiskResponseBody(name='body'),
}
async function deleteGatewayCacheDiskWithOptions(request: DeleteGatewayCacheDiskRequest, runtime: Util.RuntimeOptions): DeleteGatewayCacheDiskResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.cacheId)) {
query['CacheId'] = request.cacheId;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.localFilePath)) {
query['LocalFilePath'] = request.localFilePath;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteGatewayCacheDisk',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deleteGatewayCacheDisk(request: DeleteGatewayCacheDiskRequest): DeleteGatewayCacheDiskResponse {
var runtime = new Util.RuntimeOptions{};
return deleteGatewayCacheDiskWithOptions(request, runtime);
}
model DeleteGatewayFileSharesRequest {
force?: boolean(name='Force', example='false'),
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbv****'),
indexId?: string(name='IndexId', example='NFSalex***'),
securityToken?: string(name='SecurityToken'),
}
model DeleteGatewayFileSharesResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='t-000czaedx5koz578vk**'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000c6hshwukkcfn****'),
}
model DeleteGatewayFileSharesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteGatewayFileSharesResponseBody(name='body'),
}
async function deleteGatewayFileSharesWithOptions(request: DeleteGatewayFileSharesRequest, runtime: Util.RuntimeOptions): DeleteGatewayFileSharesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.force)) {
query['Force'] = request.force;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteGatewayFileShares',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deleteGatewayFileShares(request: DeleteGatewayFileSharesRequest): DeleteGatewayFileSharesResponse {
var runtime = new Util.RuntimeOptions{};
return deleteGatewayFileSharesWithOptions(request, runtime);
}
model DeleteGatewayLoggingRequest {
gatewayId?: string(name='GatewayId', example='gw-0001xv7je3580031***'),
securityToken?: string(name='SecurityToken'),
}
model DeleteGatewayLoggingResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='E66BF56E-068D-4308-A2D8-7FBBCE22E812'),
success?: boolean(name='Success', example='true'),
}
model DeleteGatewayLoggingResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteGatewayLoggingResponseBody(name='body'),
}
async function deleteGatewayLoggingWithOptions(request: DeleteGatewayLoggingRequest, runtime: Util.RuntimeOptions): DeleteGatewayLoggingResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteGatewayLogging',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deleteGatewayLogging(request: DeleteGatewayLoggingRequest): DeleteGatewayLoggingResponse {
var runtime = new Util.RuntimeOptions{};
return deleteGatewayLoggingWithOptions(request, runtime);
}
model DeleteGatewaySMBUserRequest {
gatewayId?: string(name='GatewayId', example='gw-000c6hshwukkbrypj***'),
securityToken?: string(name='SecurityToken'),
username?: string(name='Username', example='username'),
}
model DeleteGatewaySMBUserResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='89398CFB-4EB6-4C7E-BB3C-EF213AC8FA50'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000c6hshwukkcfn3k**'),
}
model DeleteGatewaySMBUserResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteGatewaySMBUserResponseBody(name='body'),
}
async function deleteGatewaySMBUserWithOptions(request: DeleteGatewaySMBUserRequest, runtime: Util.RuntimeOptions): DeleteGatewaySMBUserResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.username)) {
query['Username'] = request.username;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteGatewaySMBUser',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deleteGatewaySMBUser(request: DeleteGatewaySMBUserRequest): DeleteGatewaySMBUserResponse {
var runtime = new Util.RuntimeOptions{};
return deleteGatewaySMBUserWithOptions(request, runtime);
}
model DeleteStorageBundleRequest {
securityToken?: string(name='SecurityToken'),
storageBundleId?: string(name='StorageBundleId', example='sb-0001b2otnkdxrigeq***'),
}
model DeleteStorageBundleResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='28708A34-83AF-42B8-928B-40E7B3E1D719'),
success?: boolean(name='Success', example='true'),
}
model DeleteStorageBundleResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeleteStorageBundleResponseBody(name='body'),
}
async function deleteStorageBundleWithOptions(request: DeleteStorageBundleRequest, runtime: Util.RuntimeOptions): DeleteStorageBundleResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.storageBundleId)) {
query['StorageBundleId'] = request.storageBundleId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeleteStorageBundle',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deleteStorageBundle(request: DeleteStorageBundleRequest): DeleteStorageBundleResponse {
var runtime = new Util.RuntimeOptions{};
return deleteStorageBundleWithOptions(request, runtime);
}
model DeployCSGClientsRequest {
clientRegionId?: string(name='ClientRegionId'),
ecsInstanceIds?: [ string ](name='EcsInstanceIds'),
securityToken?: string(name='SecurityToken'),
vpcId?: string(name='VpcId'),
}
model DeployCSGClientsShrinkRequest {
clientRegionId?: string(name='ClientRegionId'),
ecsInstanceIdsShrink?: string(name='EcsInstanceIds'),
securityToken?: string(name='SecurityToken'),
vpcId?: string(name='VpcId'),
}
model DeployCSGClientsResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model DeployCSGClientsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeployCSGClientsResponseBody(name='body'),
}
async function deployCSGClientsWithOptions(tmpReq: DeployCSGClientsRequest, runtime: Util.RuntimeOptions): DeployCSGClientsResponse {
Util.validateModel(tmpReq);
var request = new DeployCSGClientsShrinkRequest{};
OpenApiUtil.convert(tmpReq, request);
if (!Util.isUnset(tmpReq.ecsInstanceIds)) {
request.ecsInstanceIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.ecsInstanceIds, 'EcsInstanceIds', 'json');
}
var query = {};
if (!Util.isUnset(request.clientRegionId)) {
query['ClientRegionId'] = request.clientRegionId;
}
if (!Util.isUnset(request.ecsInstanceIdsShrink)) {
query['EcsInstanceIds'] = request.ecsInstanceIdsShrink;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.vpcId)) {
query['VpcId'] = request.vpcId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeployCSGClients',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deployCSGClients(request: DeployCSGClientsRequest): DeployCSGClientsResponse {
var runtime = new Util.RuntimeOptions{};
return deployCSGClientsWithOptions(request, runtime);
}
model DeployCacheDiskRequest {
cacheConfig?: string(name='CacheConfig'),
diskCategory?: string(name='DiskCategory'),
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
sizeInGB?: int32(name='SizeInGB'),
}
model DeployCacheDiskResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model DeployCacheDiskResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeployCacheDiskResponseBody(name='body'),
}
async function deployCacheDiskWithOptions(request: DeployCacheDiskRequest, runtime: Util.RuntimeOptions): DeployCacheDiskResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.cacheConfig)) {
query['CacheConfig'] = request.cacheConfig;
}
if (!Util.isUnset(request.diskCategory)) {
query['DiskCategory'] = request.diskCategory;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.sizeInGB)) {
query['SizeInGB'] = request.sizeInGB;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeployCacheDisk',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deployCacheDisk(request: DeployCacheDiskRequest): DeployCacheDiskResponse {
var runtime = new Util.RuntimeOptions{};
return deployCacheDiskWithOptions(request, runtime);
}
model DeployGatewayRequest {
gatewayClass?: string(name='GatewayClass', example='Basic'),
gatewayId?: string(name='GatewayId', example='gw-0001xv7je3580031y***'),
securityToken?: string(name='SecurityToken'),
}
model DeployGatewayResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='8FEAFE9D-66C2-46AB-833B-35269EC7524C'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0001xv7je35800307***'),
}
model DeployGatewayResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DeployGatewayResponseBody(name='body'),
}
async function deployGatewayWithOptions(request: DeployGatewayRequest, runtime: Util.RuntimeOptions): DeployGatewayResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayClass)) {
query['GatewayClass'] = request.gatewayClass;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DeployGateway',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function deployGateway(request: DeployGatewayRequest): DeployGatewayResponse {
var runtime = new Util.RuntimeOptions{};
return deployGatewayWithOptions(request, runtime);
}
model DescribeAccountConfigRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeAccountConfigResponseBody = {
code?: string(name='Code'),
isSupportClientSideEncryption?: boolean(name='IsSupportClientSideEncryption'),
isSupportElasticGatewayBeta?: boolean(name='IsSupportElasticGatewayBeta'),
isSupportGatewayLogging?: boolean(name='IsSupportGatewayLogging'),
isSupportServerSideEncryption?: boolean(name='IsSupportServerSideEncryption'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeAccountConfigResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeAccountConfigResponseBody(name='body'),
}
async function describeAccountConfigWithOptions(request: DescribeAccountConfigRequest, runtime: Util.RuntimeOptions): DescribeAccountConfigResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeAccountConfig',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeAccountConfig(request: DescribeAccountConfigRequest): DescribeAccountConfigResponse {
var runtime = new Util.RuntimeOptions{};
return describeAccountConfigWithOptions(request, runtime);
}
model DescribeBlockVolumeSnapshotsRequest {
gatewayId?: string(name='GatewayId'),
indexId?: string(name='IndexId'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
securityToken?: string(name='SecurityToken'),
}
model DescribeBlockVolumeSnapshotsResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
requestId?: string(name='RequestId'),
snapshots?: {
snapshot?: [
{
createTime?: long(name='CreateTime'),
size?: long(name='Size'),
snapshotName?: string(name='SnapshotName'),
}
](name='Snapshot')
}(name='Snapshots'),
success?: boolean(name='Success'),
totalCount?: int32(name='TotalCount'),
}
model DescribeBlockVolumeSnapshotsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeBlockVolumeSnapshotsResponseBody(name='body'),
}
async function describeBlockVolumeSnapshotsWithOptions(request: DescribeBlockVolumeSnapshotsRequest, runtime: Util.RuntimeOptions): DescribeBlockVolumeSnapshotsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeBlockVolumeSnapshots',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeBlockVolumeSnapshots(request: DescribeBlockVolumeSnapshotsRequest): DescribeBlockVolumeSnapshotsResponse {
var runtime = new Util.RuntimeOptions{};
return describeBlockVolumeSnapshotsWithOptions(request, runtime);
}
model DescribeCSGClientTasksRequest {
clientId?: string(name='ClientId'),
clientRegionId?: string(name='ClientRegionId'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
securityToken?: string(name='SecurityToken'),
}
model DescribeCSGClientTasksResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
tasks?: [
{
createdTime?: long(name='CreatedTime'),
messageKey?: string(name='MessageKey'),
messageParams?: string(name='MessageParams'),
name?: string(name='Name'),
progress?: int32(name='Progress'),
stateCode?: string(name='StateCode'),
taskId?: string(name='TaskId'),
updatedTime?: long(name='UpdatedTime'),
}
](name='Tasks'),
totalCount?: int32(name='TotalCount'),
}
model DescribeCSGClientTasksResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeCSGClientTasksResponseBody(name='body'),
}
async function describeCSGClientTasksWithOptions(request: DescribeCSGClientTasksRequest, runtime: Util.RuntimeOptions): DescribeCSGClientTasksResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientId)) {
query['ClientId'] = request.clientId;
}
if (!Util.isUnset(request.clientRegionId)) {
query['ClientRegionId'] = request.clientRegionId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeCSGClientTasks',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeCSGClientTasks(request: DescribeCSGClientTasksRequest): DescribeCSGClientTasksResponse {
var runtime = new Util.RuntimeOptions{};
return describeCSGClientTasksWithOptions(request, runtime);
}
model DescribeCSGClientsRequest {
clientRegionId?: string(name='ClientRegionId'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
securityToken?: string(name='SecurityToken'),
}
model DescribeCSGClientsResponseBody = {
clients?: [
{
clientDeletionCommand?: string(name='ClientDeletionCommand'),
clientId?: string(name='ClientId'),
clientInstallationCommand?: string(name='ClientInstallationCommand'),
clientVersion?: string(name='ClientVersion'),
ecsInstanceId?: string(name='EcsInstanceId'),
hostInstanceId?: string(name='HostInstanceId'),
lastHeartbeatTime?: long(name='LastHeartbeatTime'),
status?: string(name='Status'),
vpcId?: string(name='VpcId'),
workDirectory?: string(name='WorkDirectory'),
}
](name='Clients'),
code?: string(name='Code'),
message?: string(name='Message'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
totalCount?: int32(name='TotalCount'),
}
model DescribeCSGClientsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeCSGClientsResponseBody(name='body'),
}
async function describeCSGClientsWithOptions(request: DescribeCSGClientsRequest, runtime: Util.RuntimeOptions): DescribeCSGClientsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientRegionId)) {
query['ClientRegionId'] = request.clientRegionId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeCSGClients',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeCSGClients(request: DescribeCSGClientsRequest): DescribeCSGClientsResponse {
var runtime = new Util.RuntimeOptions{};
return describeCSGClientsWithOptions(request, runtime);
}
model DescribeDashboardRequest {
backendBucketRegionId?: string(name='BackendBucketRegionId'),
resourceGroupId?: string(name='ResourceGroupId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeDashboardResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
overview?: string(name='Overview'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeDashboardResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeDashboardResponseBody(name='body'),
}
async function describeDashboardWithOptions(request: DescribeDashboardRequest, runtime: Util.RuntimeOptions): DescribeDashboardResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.backendBucketRegionId)) {
query['BackendBucketRegionId'] = request.backendBucketRegionId;
}
if (!Util.isUnset(request.resourceGroupId)) {
query['ResourceGroupId'] = request.resourceGroupId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeDashboard',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeDashboard(request: DescribeDashboardRequest): DescribeDashboardResponse {
var runtime = new Util.RuntimeOptions{};
return describeDashboardWithOptions(request, runtime);
}
model DescribeExpireCachesRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeExpireCachesResponseBody = {
cacheFilePaths?: string(name='CacheFilePaths'),
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeExpireCachesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeExpireCachesResponseBody(name='body'),
}
async function describeExpireCachesWithOptions(request: DescribeExpireCachesRequest, runtime: Util.RuntimeOptions): DescribeExpireCachesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeExpireCaches',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeExpireCaches(request: DescribeExpireCachesRequest): DescribeExpireCachesResponse {
var runtime = new Util.RuntimeOptions{};
return describeExpireCachesWithOptions(request, runtime);
}
model DescribeExpressSyncSharesRequest {
expressSyncIds?: string(name='ExpressSyncIds', example='sync-0002xetjdlxne2sd***,sync-0004agfrbke1l39p***'),
isExternal?: boolean(name='IsExternal', example='true'),
securityToken?: string(name='SecurityToken'),
}
model DescribeExpressSyncSharesResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='EA258616-36AD-4609-A0A6-2B17C28CBF88'),
shares?: {
share?: [
{
expressSyncId?: string(name='ExpressSyncId', example='sb-0003c7qh5yuc1z6b8***'),
expressSyncState?: string(name='ExpressSyncState', example='MNSHealthy'),
gatewayId?: string(name='GatewayId', example='gw-000245alq48e7ytg***'),
gatewayName?: string(name='GatewayName'),
gatewayRegion?: string(name='GatewayRegion', example='cn-hangzhou'),
mnsQueue?: string(name='MnsQueue', example='sgw-express-sync-queue-gw-000245alq48e7ytgxq03***'),
shareName?: string(name='ShareName', example='ji***'),
storageBundleId?: string(name='StorageBundleId', example='sb-0003c7qh5yuc1z6b8***'),
syncProgress?: int32(name='SyncProgress', example='100'),
}
](name='Share')
}(name='Shares'),
success?: boolean(name='Success', example='true'),
}
model DescribeExpressSyncSharesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeExpressSyncSharesResponseBody(name='body'),
}
async function describeExpressSyncSharesWithOptions(request: DescribeExpressSyncSharesRequest, runtime: Util.RuntimeOptions): DescribeExpressSyncSharesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.expressSyncIds)) {
query['ExpressSyncIds'] = request.expressSyncIds;
}
if (!Util.isUnset(request.isExternal)) {
query['IsExternal'] = request.isExternal;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeExpressSyncShares',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeExpressSyncShares(request: DescribeExpressSyncSharesRequest): DescribeExpressSyncSharesResponse {
var runtime = new Util.RuntimeOptions{};
return describeExpressSyncSharesWithOptions(request, runtime);
}
model DescribeExpressSyncsRequest {
bucketName?: string(name='BucketName', example='sgw***'),
bucketPrefix?: string(name='BucketPrefix', example='test***'),
securityToken?: string(name='SecurityToken'),
}
model DescribeExpressSyncsResponseBody = {
code?: string(name='Code', example='200'),
expressSyncs?: {
expressSync?: [
{
bucketName?: string(name='BucketName', example='sgw-mns***'),
bucketPrefix?: string(name='BucketPrefix', example='test***'),
bucketRegion?: string(name='BucketRegion', example='cn-hangzhou'),
description?: string(name='Description'),
expressSyncId?: string(name='ExpressSyncId', example='sync-0002xetjdlxne2sdm***'),
mnsTopic?: string(name='MnsTopic', example='sgw-express-sync-0002xetjdlxne2sdm***'),
name?: string(name='Name', example='wptest***'),
}
](name='ExpressSync')
}(name='ExpressSyncs'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='50DE1383-D4A1-433C-98A6-459C1830A888'),
success?: boolean(name='Success', example='true'),
}
model DescribeExpressSyncsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeExpressSyncsResponseBody(name='body'),
}
async function describeExpressSyncsWithOptions(request: DescribeExpressSyncsRequest, runtime: Util.RuntimeOptions): DescribeExpressSyncsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bucketName)) {
query['BucketName'] = request.bucketName;
}
if (!Util.isUnset(request.bucketPrefix)) {
query['BucketPrefix'] = request.bucketPrefix;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeExpressSyncs',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeExpressSyncs(request: DescribeExpressSyncsRequest): DescribeExpressSyncsResponse {
var runtime = new Util.RuntimeOptions{};
return describeExpressSyncsWithOptions(request, runtime);
}
model DescribeGatewayRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayResponseBody = {
activatedTime?: long(name='ActivatedTime', example='1578986214'),
buyURL?: string(name='BuyURL', example='https://expense.console.aliyun.com/?returnExpense=true#/order/list/'),
capacity?: int32(name='Capacity', example='500'),
category?: string(name='Category', example='Aliyun'),
code?: string(name='Code', example='200'),
commonBuyInstanceId?: string(name='CommonBuyInstanceId', example='i-uf6gjr3lnwhyrd6hu***'),
createdTime?: long(name='CreatedTime', example='1532099461'),
dataLoadInterval?: int32(name='DataLoadInterval', example='120'),
dataLoadType?: string(name='DataLoadType', example='once'),
description?: string(name='Description'),
ecsInstanceId?: string(name='EcsInstanceId', example='i-uf62406gy5vyao4y8***'),
elasticGateway?: boolean(name='ElasticGateway', example='false'),
elasticNodes?: {
elasticNode?: [ string ](name='ElasticNode')
}(name='ElasticNodes'),
expireStatus?: int32(name='ExpireStatus', example='0'),
expiredTime?: long(name='ExpiredTime', example='1532530021'),
gatewayClass?: string(name='GatewayClass', example='Basic'),
gatewayId?: string(name='GatewayId', example='gw-0000ewknguw5o96vn***'),
gatewayRegionId?: string(name='GatewayRegionId'),
gatewayType?: string(name='GatewayType', example='File'),
gatewayVersion?: string(name='GatewayVersion', example='1.0.39'),
highAvailability?: boolean(name='HighAvailability'),
innerIp?: string(name='InnerIp', example='172.19.55.65'),
innerIpv6Ip?: string(name='InnerIpv6Ip', example='2408:4004:110:6000:4656:f88e:1c14:e578'),
ip?: string(name='Ip', example='47.101.160.44'),
isPostPaid?: boolean(name='IsPostPaid', example='true'),
isReleaseAfterExpiration?: boolean(name='IsReleaseAfterExpiration', example='false'),
lastErrorKey?: string(name='LastErrorKey', example='InternalError'),
location?: string(name='Location', example='Cloud'),
maxThroughput?: int32(name='MaxThroughput', example='30'),
message?: string(name='Message', example='successful'),
name?: string(name='Name', example='alex***'),
publicNetworkBandwidth?: int32(name='PublicNetworkBandwidth', example='50'),
renewURL?: string(name='RenewURL', example='https://common-buy.aliyun.com/?commodityCode=hcs_sgw_csg_pre&orderType=RENEW&instanceId=ca-0007va9bnideidndn***#/renew'),
requestId?: string(name='RequestId', example='736C7733-FCED-4AFB-8407-C325F210CE03'),
status?: string(name='Status', example='Initialized'),
storageBundleId?: string(name='StorageBundleId', example='sb-000dt67z4ijqfocpy***'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0000iwdggbharrw6r***'),
type?: string(name='Type', example='File'),
untrustedEnvInstanceType?: string(name='UntrustedEnvInstanceType'),
untrustedEnvOssEndpoint?: string(name='UntrustedEnvOssEndpoint'),
vSwitchId?: string(name='VSwitchId', example='vsw-bp1b3mvml55ziekq7e***'),
vpcId?: string(name='VpcId', example='vpc-uf6j237kxmsw08auey***'),
}
model DescribeGatewayResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayResponseBody(name='body'),
}
async function describeGatewayWithOptions(request: DescribeGatewayRequest, runtime: Util.RuntimeOptions): DescribeGatewayResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGateway',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGateway(request: DescribeGatewayRequest): DescribeGatewayResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayWithOptions(request, runtime);
}
model DescribeGatewayADInfoRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayADInfoResponseBody = {
code?: string(name='Code', example='200'),
domainName?: string(name='DomainName', example='test***'),
isEnabled?: boolean(name='IsEnabled', example='true'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='1B0CA0B9-2B0F-478D-ADC5-474C45BF947F'),
serverIp?: string(name='ServerIp', example='47.101.59.199'),
success?: boolean(name='Success', example='true'),
username?: string(name='Username', example='alex***'),
}
model DescribeGatewayADInfoResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayADInfoResponseBody(name='body'),
}
async function describeGatewayADInfoWithOptions(request: DescribeGatewayADInfoRequest, runtime: Util.RuntimeOptions): DescribeGatewayADInfoResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayADInfo',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayADInfo(request: DescribeGatewayADInfoRequest): DescribeGatewayADInfoResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayADInfoWithOptions(request, runtime);
}
model DescribeGatewayActionsRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayActionsResponseBody = {
actions?: {
action?: [
{
adLdap?: string(name='AdLdap'),
cache?: string(name='Cache'),
disk?: string(name='Disk'),
gatewayId?: string(name='GatewayId'),
monitor?: string(name='Monitor'),
self?: string(name='Self'),
smbUser?: string(name='SmbUser'),
target?: string(name='Target'),
}
](name='Action')
}(name='Actions'),
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeGatewayActionsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayActionsResponseBody(name='body'),
}
async function describeGatewayActionsWithOptions(request: DescribeGatewayActionsRequest, runtime: Util.RuntimeOptions): DescribeGatewayActionsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayActions',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayActions(request: DescribeGatewayActionsRequest): DescribeGatewayActionsResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayActionsWithOptions(request, runtime);
}
model DescribeGatewayAuthInfoRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayAuthInfoResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
password?: string(name='Password'),
publicIp?: string(name='PublicIp'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
username?: string(name='Username'),
}
model DescribeGatewayAuthInfoResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayAuthInfoResponseBody(name='body'),
}
async function describeGatewayAuthInfoWithOptions(request: DescribeGatewayAuthInfoRequest, runtime: Util.RuntimeOptions): DescribeGatewayAuthInfoResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayAuthInfo',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayAuthInfo(request: DescribeGatewayAuthInfoRequest): DescribeGatewayAuthInfoResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayAuthInfoWithOptions(request, runtime);
}
model DescribeGatewayAutoPlansRequest {
gatewayId?: string(name='GatewayId'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayAutoPlansResponseBody = {
autoPlans?: [
{
detail?: string(name='Detail'),
endTime?: long(name='EndTime'),
event?: string(name='Event'),
planId?: string(name='PlanId'),
startTime?: long(name='StartTime'),
status?: string(name='Status'),
}
](name='AutoPlans'),
code?: string(name='Code'),
message?: string(name='Message'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
totalCount?: int32(name='TotalCount'),
}
model DescribeGatewayAutoPlansResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayAutoPlansResponseBody(name='body'),
}
async function describeGatewayAutoPlansWithOptions(request: DescribeGatewayAutoPlansRequest, runtime: Util.RuntimeOptions): DescribeGatewayAutoPlansResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayAutoPlans',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayAutoPlans(request: DescribeGatewayAutoPlansRequest): DescribeGatewayAutoPlansResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayAutoPlansWithOptions(request, runtime);
}
model DescribeGatewayAutoUpgradeConfigurationRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayAutoUpgradeConfigurationResponseBody = {
autoUpgradeEndHour?: int32(name='AutoUpgradeEndHour'),
autoUpgradeStartHour?: int32(name='AutoUpgradeStartHour'),
code?: string(name='Code'),
isAutoUpgrade?: boolean(name='IsAutoUpgrade'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeGatewayAutoUpgradeConfigurationResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayAutoUpgradeConfigurationResponseBody(name='body'),
}
async function describeGatewayAutoUpgradeConfigurationWithOptions(request: DescribeGatewayAutoUpgradeConfigurationRequest, runtime: Util.RuntimeOptions): DescribeGatewayAutoUpgradeConfigurationResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayAutoUpgradeConfiguration',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayAutoUpgradeConfiguration(request: DescribeGatewayAutoUpgradeConfigurationRequest): DescribeGatewayAutoUpgradeConfigurationResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayAutoUpgradeConfigurationWithOptions(request, runtime);
}
model DescribeGatewayBlockVolumesRequest {
gatewayId?: string(name='GatewayId', example='gw-000dt67z4ijngqvh***'),
indexId?: string(name='IndexId', example='alex-or2020010816***'),
refresh?: boolean(name='Refresh', example='true'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayBlockVolumesResponseBody = {
blockVolumes?: {
blockVolume?: [
{
address?: string(name='Address', example='172.16.0.22'),
cacheMode?: string(name='CacheMode', example='Cache'),
chapEnabled?: boolean(name='ChapEnabled', example='true'),
chapInUser?: string(name='ChapInUser', example='alex***'),
chunkSize?: int32(name='ChunkSize', example='32768'),
diskId?: string(name='DiskId', example='d-bp1a8athxvwbja18***'),
diskType?: string(name='DiskType', example='cloud_efficiency'),
enabled?: boolean(name='Enabled', example='true'),
indexId?: string(name='IndexId', example='alex-or2020010816***'),
localPath?: string(name='LocalPath', example='/dev/vdb'),
lunId?: int32(name='LunId', description='LUN ID。', example='0'),
name?: string(name='Name', example='alex'),
ossBucketName?: string(name='OssBucketName', example='random***'),
ossBucketSsl?: boolean(name='OssBucketSsl', example='true'),
ossEndpoint?: string(name='OssEndpoint', example='oss-cn-hangzhou-internal.aliyuncs.com'),
port?: int32(name='Port', example='0'),
protocol?: string(name='Protocol', example='iSCSI'),
size?: long(name='Size', example='107374182400'),
state?: string(name='State', example='clean'),
status?: int32(name='Status', example='0'),
target?: string(name='Target', example='iqn**************'),
totalDownload?: long(name='TotalDownload', example='56342324'),
totalUpload?: long(name='TotalUpload', example='123214564'),
volumeState?: int32(name='VolumeState', example='1'),
}
](name='BlockVolume')
}(name='BlockVolumes'),
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='787D4AD4-5536-4C36-9FB0-D74C0554D344'),
success?: boolean(name='Success', example='true'),
}
model DescribeGatewayBlockVolumesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayBlockVolumesResponseBody(name='body'),
}
/**
* ****
*
* @param request DescribeGatewayBlockVolumesRequest
* @param runtime runtime options for this request RuntimeOptions
* @return DescribeGatewayBlockVolumesResponse
*/
async function describeGatewayBlockVolumesWithOptions(request: DescribeGatewayBlockVolumesRequest, runtime: Util.RuntimeOptions): DescribeGatewayBlockVolumesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.refresh)) {
query['Refresh'] = request.refresh;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayBlockVolumes',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
/**
* ****
*
* @param request DescribeGatewayBlockVolumesRequest
* @return DescribeGatewayBlockVolumesResponse
*/
async function describeGatewayBlockVolumes(request: DescribeGatewayBlockVolumesRequest): DescribeGatewayBlockVolumesResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayBlockVolumesWithOptions(request, runtime);
}
model DescribeGatewayBucketCachesRequest {
bucketName?: string(name='BucketName'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayBucketCachesResponseBody = {
bucketCaches?: {
bucketCache?: [
{
bucketName?: string(name='BucketName'),
cacheMode?: string(name='CacheMode'),
cacheStats?: string(name='CacheStats'),
category?: string(name='Category'),
gatewayId?: string(name='GatewayId'),
gatewayName?: string(name='GatewayName'),
location?: string(name='Location'),
mountPoint?: string(name='MountPoint'),
protocol?: string(name='Protocol'),
regionId?: string(name='RegionId'),
shareName?: string(name='ShareName'),
type?: string(name='Type'),
vpcCidr?: string(name='VpcCidr'),
vpcId?: string(name='VpcId'),
}
](name='BucketCache')
}(name='BucketCaches'),
code?: string(name='Code'),
message?: string(name='Message'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
totalCount?: int32(name='TotalCount'),
}
model DescribeGatewayBucketCachesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayBucketCachesResponseBody(name='body'),
}
async function describeGatewayBucketCachesWithOptions(request: DescribeGatewayBucketCachesRequest, runtime: Util.RuntimeOptions): DescribeGatewayBucketCachesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bucketName)) {
query['BucketName'] = request.bucketName;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayBucketCaches',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayBucketCaches(request: DescribeGatewayBucketCachesRequest): DescribeGatewayBucketCachesResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayBucketCachesWithOptions(request, runtime);
}
model DescribeGatewayCachesRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayCachesResponseBody = {
caches?: {
cache?: [
{
buyURL?: string(name='BuyURL'),
cacheId?: string(name='CacheId', example='d-bp1dcnq8zldree6ok***'),
cacheType?: string(name='CacheType', example='cloud_efficiency'),
expireStatus?: int32(name='ExpireStatus', example='0'),
expiredTime?: long(name='ExpiredTime', example='1532510649'),
iops?: long(name='Iops', description='IOPS。', example='2605'),
isDirectExpand?: string(name='IsDirectExpand'),
isNoPartition?: boolean(name='IsNoPartition'),
isUsed?: boolean(name='IsUsed', example='false'),
localFilePath?: string(name='LocalFilePath', example='/dev/vdb'),
performanceLevel?: string(name='PerformanceLevel'),
renewURL?: string(name='RenewURL', example='https://common-buy.aliyun.com/?commodityCode=hcs_sgw_csg_pre&orderType=RENEW&instanceId=ca-0007va9bnideidnd***#/renew'),
sizeInGB?: long(name='SizeInGB', example='101'),
subscriptionInstanceId?: string(name='SubscriptionInstanceId'),
}
](name='Cache')
}(name='Caches'),
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='40797B4D-09D9-482E-B163-CCB568BADE35'),
success?: boolean(name='Success', example='true'),
}
model DescribeGatewayCachesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayCachesResponseBody(name='body'),
}
async function describeGatewayCachesWithOptions(request: DescribeGatewayCachesRequest, runtime: Util.RuntimeOptions): DescribeGatewayCachesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayCaches',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayCaches(request: DescribeGatewayCachesRequest): DescribeGatewayCachesResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayCachesWithOptions(request, runtime);
}
model DescribeGatewayCapacityLimitRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
sizeInGB?: long(name='SizeInGB'),
}
model DescribeGatewayCapacityLimitResponseBody = {
code?: string(name='Code'),
fileNumber?: long(name='FileNumber'),
fileSystemSizeInTB?: long(name='FileSystemSizeInTB'),
isMetadataSeparate?: boolean(name='IsMetadataSeparate'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeGatewayCapacityLimitResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayCapacityLimitResponseBody(name='body'),
}
async function describeGatewayCapacityLimitWithOptions(request: DescribeGatewayCapacityLimitRequest, runtime: Util.RuntimeOptions): DescribeGatewayCapacityLimitResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.sizeInGB)) {
query['SizeInGB'] = request.sizeInGB;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayCapacityLimit',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayCapacityLimit(request: DescribeGatewayCapacityLimitRequest): DescribeGatewayCapacityLimitResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayCapacityLimitWithOptions(request, runtime);
}
model DescribeGatewayCategoriesRequest {
gatewayLocation?: string(name='GatewayLocation'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayCategoriesResponseBody = {
categories?: string(name='Categories'),
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeGatewayCategoriesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayCategoriesResponseBody(name='body'),
}
async function describeGatewayCategoriesWithOptions(request: DescribeGatewayCategoriesRequest, runtime: Util.RuntimeOptions): DescribeGatewayCategoriesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayLocation)) {
query['GatewayLocation'] = request.gatewayLocation;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayCategories',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayCategories(request: DescribeGatewayCategoriesRequest): DescribeGatewayCategoriesResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayCategoriesWithOptions(request, runtime);
}
model DescribeGatewayClassesRequest {
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayClassesResponseBody = {
classes?: string(name='Classes', example='Basic,Standard,Enhanced,Advanced'),
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='EC3D33E5-0F6B-4D1B-9B35-59A71EB3FA50'),
success?: boolean(name='Success', example='true'),
}
model DescribeGatewayClassesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayClassesResponseBody(name='body'),
}
async function describeGatewayClassesWithOptions(request: DescribeGatewayClassesRequest, runtime: Util.RuntimeOptions): DescribeGatewayClassesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayClasses',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayClasses(request: DescribeGatewayClassesRequest): DescribeGatewayClassesResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayClassesWithOptions(request, runtime);
}
model DescribeGatewayCredentialRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayCredentialResponseBody = {
code?: string(name='Code'),
consolePassword?: string(name='ConsolePassword'),
consoleUsername?: string(name='ConsoleUsername'),
ecsIp?: string(name='EcsIp'),
ecsPassword?: string(name='EcsPassword'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
vSwitchId?: string(name='VSwitchId'),
vpcId?: string(name='VpcId'),
}
model DescribeGatewayCredentialResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayCredentialResponseBody(name='body'),
}
async function describeGatewayCredentialWithOptions(request: DescribeGatewayCredentialRequest, runtime: Util.RuntimeOptions): DescribeGatewayCredentialResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayCredential',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayCredential(request: DescribeGatewayCredentialRequest): DescribeGatewayCredentialResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayCredentialWithOptions(request, runtime);
}
model DescribeGatewayDNSRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayDNSResponseBody = {
code?: string(name='Code', example='200'),
dnsServer?: string(name='DnsServer', example='100.100.2.136,100.100.2.188'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='89398CFB-4EB6-4C7E-BB3C-EF213AC8FA50'),
success?: boolean(name='Success', example='true'),
}
model DescribeGatewayDNSResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayDNSResponseBody(name='body'),
}
async function describeGatewayDNSWithOptions(request: DescribeGatewayDNSRequest, runtime: Util.RuntimeOptions): DescribeGatewayDNSResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayDNS',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayDNS(request: DescribeGatewayDNSRequest): DescribeGatewayDNSResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayDNSWithOptions(request, runtime);
}
model DescribeGatewayFileSharesRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
indexId?: string(name='IndexId', example='NFSd-million'),
refresh?: boolean(name='Refresh', example='true'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayFileSharesResponseBody = {
code?: string(name='Code', example='200'),
fileShares?: {
fileShare?: [
{
accessBasedEnumeration?: boolean(name='AccessBasedEnumeration', example='false'),
activeMessages?: long(name='ActiveMessages'),
address?: string(name='Address', example='172.16.0.44'),
beLimit?: int32(name='BeLimit', example='0'),
browsable?: boolean(name='Browsable', example='true'),
bucketInfos?: string(name='BucketInfos', example='xxxxx'),
bucketsStub?: boolean(name='BucketsStub', example='false'),
bypassCacheRead?: boolean(name='BypassCacheRead'),
cacheMode?: string(name='CacheMode', example='Cache'),
clientSideCmk?: string(name='ClientSideCmk', example='xxxxx'),
clientSideEncryption?: boolean(name='ClientSideEncryption', example='false'),
directIO?: boolean(name='DirectIO', example='false'),
diskId?: string(name='DiskId', example='d-bp1cvy8o2569jij31***'),
diskType?: string(name='DiskType', example='cloud_efficiency'),
downloadLimit?: int32(name='DownloadLimit', example='0'),
downloadQueue?: long(name='DownloadQueue'),
downloadRate?: long(name='DownloadRate'),
enabled?: boolean(name='Enabled', example='true'),
expressSyncId?: string(name='ExpressSyncId', example='sync-0001xv7je357xn8tr***'),
fastReclaim?: boolean(name='FastReclaim', example='false'),
feLimit?: int32(name='FeLimit', example='0'),
fileNumLimit?: long(name='FileNumLimit', example='10200202'),
fsSizeLimit?: long(name='FsSizeLimit', example='70368744177664'),
highWatermark?: int32(name='HighWatermark'),
ignoreDelete?: boolean(name='IgnoreDelete', example='false'),
inPlace?: boolean(name='InPlace', example='false'),
inRate?: long(name='InRate', example='0'),
indexId?: string(name='IndexId', example='NFSale***'),
kmsRotatePeriod?: string(name='KmsRotatePeriod', example='0'),
lagPeriod?: long(name='LagPeriod', example='5'),
localPath?: string(name='LocalPath', example='/dev/vdb'),
lowWatermark?: int32(name='LowWatermark'),
mnsHealth?: string(name='MnsHealth', example='MNSNotEnabled'),
name?: string(name='Name', example='alex***'),
nfsV4Optimization?: boolean(name='NfsV4Optimization', example='false'),
noPartition?: boolean(name='NoPartition'),
obsoleteBuckets?: string(name='ObsoleteBuckets', example='bucket1'),
ossBucketName?: string(name='OssBucketName', example='bucketA'),
ossBucketSsl?: boolean(name='OssBucketSsl', example='false'),
ossEndpoint?: string(name='OssEndpoint', example='oss-cn-hangzhou-internal.aliyuncs.com'),
ossHealth?: string(name='OssHealth', example='BucketHealthy'),
ossUsed?: long(name='OssUsed', example='0'),
outRate?: long(name='OutRate', example='0'),
partialSyncPaths?: string(name='PartialSyncPaths', example='xxxxx'),
pathPrefix?: string(name='PathPrefix', description='OSS Prefix。', example='testprefix'),
pollingInterval?: int32(name='PollingInterval', example='0'),
protocol?: string(name='Protocol', example='SMB'),
remainingMetaSpace?: long(name='RemainingMetaSpace', example='21308227584'),
remoteSync?: boolean(name='RemoteSync', example='false'),
remoteSyncDownload?: boolean(name='RemoteSyncDownload', example='false'),
roClientList?: string(name='RoClientList', example='user1'),
roUserList?: string(name='RoUserList', example='user2'),
rwClientList?: string(name='RwClientList', example='user3'),
rwUserList?: string(name='RwUserList', example='user4'),
serverSideAlgorithm?: string(name='ServerSideAlgorithm'),
serverSideCmk?: string(name='ServerSideCmk', example='xxxxx'),
serverSideEncryption?: boolean(name='ServerSideEncryption', example='false'),
size?: long(name='Size', example='85899345920'),
squash?: string(name='Squash', example='root_squash'),
state?: string(name='State', example='clean'),
status?: string(name='Status'),
supportArchive?: boolean(name='SupportArchive', example='false'),
syncProgress?: int32(name='SyncProgress', example='-2'),
throttling?: boolean(name='Throttling'),
totalDownload?: long(name='TotalDownload', example='0'),
totalUpload?: long(name='TotalUpload', example='0'),
transferAcceleration?: boolean(name='TransferAcceleration', example='false'),
uploadQueue?: long(name='UploadQueue'),
used?: long(name='Used', example='0'),
windowsAcl?: boolean(name='WindowsAcl', example='false'),
}
](name='FileShare')
}(name='FileShares'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='9A3C3C32-3F37-4658-9D38-945D0799CA0E'),
success?: boolean(name='Success', example='true'),
}
model DescribeGatewayFileSharesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayFileSharesResponseBody(name='body'),
}
async function describeGatewayFileSharesWithOptions(request: DescribeGatewayFileSharesRequest, runtime: Util.RuntimeOptions): DescribeGatewayFileSharesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.refresh)) {
query['Refresh'] = request.refresh;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayFileShares',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayFileShares(request: DescribeGatewayFileSharesRequest): DescribeGatewayFileSharesResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayFileSharesWithOptions(request, runtime);
}
model DescribeGatewayFileStatusRequest {
filePath?: string(name='FilePath'),
gatewayId?: string(name='GatewayId'),
indexId?: string(name='IndexId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayFileStatusResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
status?: string(name='Status'),
success?: boolean(name='Success'),
}
model DescribeGatewayFileStatusResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayFileStatusResponseBody(name='body'),
}
async function describeGatewayFileStatusWithOptions(request: DescribeGatewayFileStatusRequest, runtime: Util.RuntimeOptions): DescribeGatewayFileStatusResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.filePath)) {
query['FilePath'] = request.filePath;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayFileStatus',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayFileStatus(request: DescribeGatewayFileStatusRequest): DescribeGatewayFileStatusResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayFileStatusWithOptions(request, runtime);
}
model DescribeGatewayImagesRequest {
securityToken?: string(name='SecurityToken'),
type?: string(name='Type', example='File'),
}
model DescribeGatewayImagesResponseBody = {
code?: string(name='Code', example='200'),
images?: {
image?: [
{
description?: string(name='Description', example='sgw.file.kvm.description'),
MD5?: string(name='MD5', example='48f43e6a906b28ed30ec40d8***'),
modifiedDate?: string(name='ModifiedDate', example='2019-07-24'),
name?: string(name='Name', example='aliyun/file/1.0.40/image/sgw-file-1.0.39.v***'),
size?: long(name='Size', example='1063744588'),
title?: string(name='Title', example='sgw.file.kvm.title'),
type?: string(name='Type', example='application/octet-stream'),
url?: string(name='Url', example='http://sgw-gateway.oss-cn-shanghai.aliyuncs.com/aliyun/file/1.0.40/image/sgw-file-1.0.40.qcow2?Expires=1564045229&OSSAccessKeyId=LTAINaSMVqr8***&Signature=%2BoTNVCGWgxis8GMpvpg5NIRkFvE%3D'),
version?: string(name='Version', example='1.0.40'),
}
](name='Image')
}(name='Images'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='30DFF66156-3672-4204-B708-24389F01FC77'),
success?: boolean(name='Success', example='true'),
}
model DescribeGatewayImagesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayImagesResponseBody(name='body'),
}
async function describeGatewayImagesWithOptions(request: DescribeGatewayImagesRequest, runtime: Util.RuntimeOptions): DescribeGatewayImagesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.type)) {
query['Type'] = request.type;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayImages',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayImages(request: DescribeGatewayImagesRequest): DescribeGatewayImagesResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayImagesWithOptions(request, runtime);
}
model DescribeGatewayInfoRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayInfoResponseBody = {
code?: string(name='Code'),
gatewayInfos?: {
gatewayInfo?: [
{
info?: string(name='Info'),
time?: long(name='Time'),
}
](name='GatewayInfo')
}(name='GatewayInfos'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeGatewayInfoResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayInfoResponseBody(name='body'),
}
async function describeGatewayInfoWithOptions(request: DescribeGatewayInfoRequest, runtime: Util.RuntimeOptions): DescribeGatewayInfoResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayInfo',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayInfo(request: DescribeGatewayInfoRequest): DescribeGatewayInfoResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayInfoWithOptions(request, runtime);
}
model DescribeGatewayLDAPInfoRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayLDAPInfoResponseBody = {
baseDN?: string(name='BaseDN', example='dc=sgwte***,dc=local'),
code?: string(name='Code', example='200'),
isEnabled?: boolean(name='IsEnabled', example='true'),
isTls?: boolean(name='IsTls', example='false'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='89398CFB-4EB6-4C7E-BB3C-EF213AC8FA**'),
rootDN?: string(name='RootDN', example='cn=admin,dc=sgwte***,dc=local'),
serverIp?: string(name='ServerIp', example='47.101.59.188'),
success?: boolean(name='Success', example='true'),
}
model DescribeGatewayLDAPInfoResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayLDAPInfoResponseBody(name='body'),
}
async function describeGatewayLDAPInfoWithOptions(request: DescribeGatewayLDAPInfoRequest, runtime: Util.RuntimeOptions): DescribeGatewayLDAPInfoResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayLDAPInfo',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayLDAPInfo(request: DescribeGatewayLDAPInfoRequest): DescribeGatewayLDAPInfoResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayLDAPInfoWithOptions(request, runtime);
}
model DescribeGatewayLocationsRequest {
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayLocationsResponseBody = {
code?: string(name='Code'),
locations?: string(name='Locations'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeGatewayLocationsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayLocationsResponseBody(name='body'),
}
async function describeGatewayLocationsWithOptions(request: DescribeGatewayLocationsRequest, runtime: Util.RuntimeOptions): DescribeGatewayLocationsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayLocations',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayLocations(request: DescribeGatewayLocationsRequest): DescribeGatewayLocationsResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayLocationsWithOptions(request, runtime);
}
model DescribeGatewayLoggingRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwb***'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayLoggingResponseBody = {
code?: string(name='Code', example='200'),
gatewayLoggingStatus?: string(name='GatewayLoggingStatus', example='Enabled'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='17D08346-BD08-4107-BFBC-01A6AAD5F5FB'),
slsLogstore?: string(name='SlsLogstore', example='alex***'),
slsProject?: string(name='SlsProject', example='123***'),
success?: boolean(name='Success', example='true'),
}
model DescribeGatewayLoggingResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayLoggingResponseBody(name='body'),
}
async function describeGatewayLoggingWithOptions(request: DescribeGatewayLoggingRequest, runtime: Util.RuntimeOptions): DescribeGatewayLoggingResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayLogging',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayLogging(request: DescribeGatewayLoggingRequest): DescribeGatewayLoggingResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayLoggingWithOptions(request, runtime);
}
model DescribeGatewayLogsRequest {
gatewayId?: string(name='GatewayId'),
logFilePath?: string(name='LogFilePath'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayLogsResponseBody = {
code?: string(name='Code'),
logFilePaths?: string(name='LogFilePaths'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeGatewayLogsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayLogsResponseBody(name='body'),
}
async function describeGatewayLogsWithOptions(request: DescribeGatewayLogsRequest, runtime: Util.RuntimeOptions): DescribeGatewayLogsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.logFilePath)) {
query['LogFilePath'] = request.logFilePath;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayLogs',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayLogs(request: DescribeGatewayLogsRequest): DescribeGatewayLogsResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayLogsWithOptions(request, runtime);
}
model DescribeGatewayModificationClassesRequest {
gatewayId?: string(name='GatewayId', example='gw-0001xv7je3580031***'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayModificationClassesResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='FA8951CC-A534-425D-8705-F9A5CF9FD555'),
success?: boolean(name='Success', example='true'),
targetGatewayClasses?: {
targetGatewayClass?: [
{
gatewayClass?: string(name='GatewayClass', example='Enhanced'),
isAvailable?: boolean(name='IsAvailable', example='true'),
}
](name='TargetGatewayClass')
}(name='TargetGatewayClasses'),
}
model DescribeGatewayModificationClassesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayModificationClassesResponseBody(name='body'),
}
async function describeGatewayModificationClassesWithOptions(request: DescribeGatewayModificationClassesRequest, runtime: Util.RuntimeOptions): DescribeGatewayModificationClassesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayModificationClasses',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayModificationClasses(request: DescribeGatewayModificationClassesRequest): DescribeGatewayModificationClassesResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayModificationClassesWithOptions(request, runtime);
}
model DescribeGatewayNFSClientsRequest {
gatewayId?: string(name='GatewayId'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayNFSClientsResponseBody = {
clientInfoList?: {
clientInfo?: [
{
clientIpAddr?: string(name='ClientIpAddr'),
hasNFSv3?: boolean(name='HasNFSv3'),
hasNFSv40?: boolean(name='HasNFSv40'),
hasNFSv41?: boolean(name='HasNFSv41'),
}
](name='ClientInfo')
}(name='ClientInfoList'),
code?: string(name='Code'),
message?: string(name='Message'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
totalCount?: int32(name='TotalCount'),
version3Enabled?: boolean(name='Version3Enabled'),
version40Enabled?: boolean(name='Version40Enabled'),
version41Enabled?: boolean(name='Version41Enabled'),
}
model DescribeGatewayNFSClientsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayNFSClientsResponseBody(name='body'),
}
async function describeGatewayNFSClientsWithOptions(request: DescribeGatewayNFSClientsRequest, runtime: Util.RuntimeOptions): DescribeGatewayNFSClientsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayNFSClients',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayNFSClients(request: DescribeGatewayNFSClientsRequest): DescribeGatewayNFSClientsResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayNFSClientsWithOptions(request, runtime);
}
model DescribeGatewaySMBUsersRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbv***'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewaySMBUsersResponseBody = {
activeDirectory?: boolean(name='ActiveDirectory'),
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
requestId?: string(name='RequestId', example='4C02F482-FC2E-45BF-88C5-8D40134D11**'),
success?: boolean(name='Success', example='true'),
totalCount?: int32(name='TotalCount', example='1'),
users?: {
user?: [
{
username?: string(name='Username', example='alex***'),
}
](name='User')
}(name='Users'),
}
model DescribeGatewaySMBUsersResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewaySMBUsersResponseBody(name='body'),
}
async function describeGatewaySMBUsersWithOptions(request: DescribeGatewaySMBUsersRequest, runtime: Util.RuntimeOptions): DescribeGatewaySMBUsersResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewaySMBUsers',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewaySMBUsers(request: DescribeGatewaySMBUsersRequest): DescribeGatewaySMBUsersResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewaySMBUsersWithOptions(request, runtime);
}
model DescribeGatewayStatisticsRequest {
endTimestamp?: long(name='EndTimestamp'),
gatewayCategory?: string(name='GatewayCategory'),
gatewayLocation?: string(name='GatewayLocation'),
securityToken?: string(name='SecurityToken'),
startTimestamp?: long(name='StartTimestamp'),
targetAccountId?: string(name='TargetAccountId'),
}
model DescribeGatewayStatisticsResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
result?: string(name='Result'),
success?: boolean(name='Success'),
}
model DescribeGatewayStatisticsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayStatisticsResponseBody(name='body'),
}
async function describeGatewayStatisticsWithOptions(request: DescribeGatewayStatisticsRequest, runtime: Util.RuntimeOptions): DescribeGatewayStatisticsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.endTimestamp)) {
query['EndTimestamp'] = request.endTimestamp;
}
if (!Util.isUnset(request.gatewayCategory)) {
query['GatewayCategory'] = request.gatewayCategory;
}
if (!Util.isUnset(request.gatewayLocation)) {
query['GatewayLocation'] = request.gatewayLocation;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.startTimestamp)) {
query['StartTimestamp'] = request.startTimestamp;
}
if (!Util.isUnset(request.targetAccountId)) {
query['TargetAccountId'] = request.targetAccountId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayStatistics',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayStatistics(request: DescribeGatewayStatisticsRequest): DescribeGatewayStatisticsResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayStatisticsWithOptions(request, runtime);
}
model DescribeGatewayStockRequest {
gatewayRegionId?: string(name='GatewayRegionId', example='cn-shanghai'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayStockResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='6342F2A5-6E24-415E-8B2B-91D88868C89F'),
stocks?: {
stock?: [
{
stockInfo?: string(name='StockInfo', example='{"Basic":true,"Advanced":false,"Enhanced":false,"Standard":true}'),
zoneId?: string(name='ZoneId', example='cn-shanghai-f'),
}
](name='Stock')
}(name='Stocks'),
success?: boolean(name='Success', example='true'),
}
model DescribeGatewayStockResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayStockResponseBody(name='body'),
}
async function describeGatewayStockWithOptions(request: DescribeGatewayStockRequest, runtime: Util.RuntimeOptions): DescribeGatewayStockResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayRegionId)) {
query['GatewayRegionId'] = request.gatewayRegionId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayStock',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayStock(request: DescribeGatewayStockRequest): DescribeGatewayStockResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayStockWithOptions(request, runtime);
}
model DescribeGatewayTypesRequest {
gatewayLocation?: string(name='GatewayLocation', example='Cloud'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewayTypesResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='787ECFD0-5F30-44C0-BB8F-56A964F66D01'),
success?: boolean(name='Success', example='true'),
types?: string(name='Types', example='File,Iscsi'),
}
model DescribeGatewayTypesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewayTypesResponseBody(name='body'),
}
async function describeGatewayTypesWithOptions(request: DescribeGatewayTypesRequest, runtime: Util.RuntimeOptions): DescribeGatewayTypesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayLocation)) {
query['GatewayLocation'] = request.gatewayLocation;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewayTypes',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewayTypes(request: DescribeGatewayTypesRequest): DescribeGatewayTypesResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewayTypesWithOptions(request, runtime);
}
model DescribeGatewaysRequest {
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
securityToken?: string(name='SecurityToken'),
storageBundleId?: string(name='StorageBundleId', example='sb-0001b2otnkdxrigeq***'),
}
model DescribeGatewaysResponseBody = {
code?: string(name='Code', example='200'),
gateways?: {
gateway?: [
{
activatedTime?: long(name='ActivatedTime', example='1577179769'),
buyURL?: string(name='BuyURL', example='https://common-buy.aliyun.com/?commodityCode=hcs_sgw_csg_pre&request={"gateway_id":"gw-0007va9bnidei3s8a***”,”directBuy":"false","gateway_class":"standard","cache_cloud_efficiency_size":0}®ionId=cn-hangzhou#/buy'),
capacity?: int32(name='Capacity'),
category?: string(name='Category', example='Aliyun'),
commonBuyInstanceId?: string(name='CommonBuyInstanceId', example='gw-0001b2onkdzvl3b***'),
createdTime?: long(name='CreatedTime', example='1577179604'),
dataLoadInterval?: int32(name='DataLoadInterval'),
dataLoadType?: string(name='DataLoadType'),
description?: string(name='Description'),
ecsInstanceId?: string(name='EcsInstanceId', example='gw-0001b2onkdzvl3b***'),
elasticGateway?: boolean(name='ElasticGateway'),
elasticNodes?: {
elasticNode?: [ string ](name='ElasticNode')
}(name='ElasticNodes'),
expireStatus?: int32(name='ExpireStatus', example='0'),
expiredTime?: long(name='ExpiredTime', example='1532426471'),
gatewayClass?: string(name='GatewayClass', example='Advanced'),
gatewayId?: string(name='GatewayId', example='gw-0001b2odzvl3b1mhi***'),
gatewayRegionId?: string(name='GatewayRegionId'),
gatewayType?: string(name='GatewayType', example='File'),
gatewayVersion?: string(name='GatewayVersion', example='1.2.6'),
highAvailability?: boolean(name='HighAvailability'),
innerIp?: string(name='InnerIp', example='172.16.0.21'),
innerIpv6Ip?: string(name='InnerIpv6Ip'),
ip?: string(name='Ip', example='47.111.145.66'),
isPostPaid?: boolean(name='IsPostPaid', example='true'),
isReleaseAfterExpiration?: boolean(name='IsReleaseAfterExpiration', example='false'),
lastErrorKey?: string(name='LastErrorKey'),
location?: string(name='Location', example='Cloud'),
maxThroughput?: int32(name='MaxThroughput'),
name?: string(name='Name', example='fio-weekly***'),
publicNetworkBandwidth?: int32(name='PublicNetworkBandwidth', example='55'),
renewURL?: string(name='RenewURL', example='https://common-buy.aliyun.com/?commodityCode=hcs_sgw_csg_pre&orderType=RENEW&instanceId=ca-0007va9bnideidndnu72#/renew'),
status?: string(name='Status', example='Running'),
storageBundleId?: string(name='StorageBundleId', example='sb-0001b2otrigeqkso***'),
taskId?: string(name='TaskId', example='t-000978oflgrd8ah6p***'),
type?: string(name='Type', example='File'),
untrustedEnvInstanceType?: string(name='UntrustedEnvInstanceType'),
vSwitchId?: string(name='VSwitchId', example='vsw-bp1krhkgnahkb9stp0***'),
vpcId?: string(name='VpcId', example='vpc-bp1p0usrgr5z9e7lwr***'),
}
](name='Gateway')
}(name='Gateways'),
message?: string(name='Message', example='successful'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
requestId?: string(name='RequestId', example='2C4A8287-66F4-45F9-84E3-866E4232C763'),
success?: boolean(name='Success', example='true'),
totalCount?: int32(name='TotalCount', example='2'),
}
model DescribeGatewaysResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewaysResponseBody(name='body'),
}
async function describeGatewaysWithOptions(request: DescribeGatewaysRequest, runtime: Util.RuntimeOptions): DescribeGatewaysResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.storageBundleId)) {
query['StorageBundleId'] = request.storageBundleId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGateways',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGateways(request: DescribeGatewaysRequest): DescribeGatewaysResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewaysWithOptions(request, runtime);
}
model DescribeGatewaysForCmsRequest {
gatewayRegionId?: string(name='GatewayRegionId'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
securityToken?: string(name='SecurityToken'),
}
model DescribeGatewaysForCmsResponseBody = {
code?: string(name='Code'),
gateways?: {
gateway?: [
{
description?: string(name='Description'),
gatewayId?: string(name='GatewayId'),
name?: string(name='Name'),
}
](name='Gateway')
}(name='Gateways'),
message?: string(name='Message'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
totalCount?: int32(name='TotalCount'),
}
model DescribeGatewaysForCmsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewaysForCmsResponseBody(name='body'),
}
async function describeGatewaysForCmsWithOptions(request: DescribeGatewaysForCmsRequest, runtime: Util.RuntimeOptions): DescribeGatewaysForCmsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayRegionId)) {
query['GatewayRegionId'] = request.gatewayRegionId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewaysForCms',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewaysForCms(request: DescribeGatewaysForCmsRequest): DescribeGatewaysForCmsResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewaysForCmsWithOptions(request, runtime);
}
model DescribeGatewaysTagsRequest {
gatewayIds?: string(name='GatewayIds'),
securityToken?: string(name='SecurityToken'),
storageBundleId?: string(name='StorageBundleId'),
tagCategory?: string(name='TagCategory'),
}
model DescribeGatewaysTagsResponseBody = {
code?: string(name='Code'),
gatewayTags?: {
gatewayTag?: [
{
gatewayId?: string(name='GatewayId'),
tags?: {
tag?: [
{
tagKey?: string(name='TagKey'),
tagValue?: string(name='TagValue'),
}
](name='Tag')
}(name='Tags'),
}
](name='GatewayTag')
}(name='GatewayTags'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeGatewaysTagsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeGatewaysTagsResponseBody(name='body'),
}
async function describeGatewaysTagsWithOptions(request: DescribeGatewaysTagsRequest, runtime: Util.RuntimeOptions): DescribeGatewaysTagsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayIds)) {
query['GatewayIds'] = request.gatewayIds;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.storageBundleId)) {
query['StorageBundleId'] = request.storageBundleId;
}
if (!Util.isUnset(request.tagCategory)) {
query['TagCategory'] = request.tagCategory;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeGatewaysTags',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeGatewaysTags(request: DescribeGatewaysTagsRequest): DescribeGatewaysTagsResponse {
var runtime = new Util.RuntimeOptions{};
return describeGatewaysTagsWithOptions(request, runtime);
}
model DescribeKmsKeyRequest {
gatewayId?: string(name='GatewayId'),
kmsKey?: string(name='KmsKey'),
securityToken?: string(name='SecurityToken'),
}
model DescribeKmsKeyResponseBody = {
code?: string(name='Code'),
isValid?: boolean(name='IsValid'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeKmsKeyResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeKmsKeyResponseBody(name='body'),
}
async function describeKmsKeyWithOptions(request: DescribeKmsKeyRequest, runtime: Util.RuntimeOptions): DescribeKmsKeyResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.kmsKey)) {
query['KmsKey'] = request.kmsKey;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeKmsKey',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeKmsKey(request: DescribeKmsKeyRequest): DescribeKmsKeyResponse {
var runtime = new Util.RuntimeOptions{};
return describeKmsKeyWithOptions(request, runtime);
}
model DescribeMqttConfigRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeMqttConfigResponseBody = {
authType?: string(name='AuthType'),
brokerUrl?: string(name='BrokerUrl'),
code?: string(name='Code'),
groupId?: string(name='GroupId'),
internalBrokerUrl?: string(name='InternalBrokerUrl'),
isEnabled?: boolean(name='IsEnabled'),
message?: string(name='Message'),
mqttInstanceId?: string(name='MqttInstanceId'),
password?: string(name='Password'),
publishTopic?: string(name='PublishTopic'),
requestId?: string(name='RequestId'),
subscribeTopic?: string(name='SubscribeTopic'),
success?: boolean(name='Success'),
username?: string(name='Username'),
}
model DescribeMqttConfigResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeMqttConfigResponseBody(name='body'),
}
async function describeMqttConfigWithOptions(request: DescribeMqttConfigRequest, runtime: Util.RuntimeOptions): DescribeMqttConfigResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeMqttConfig',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeMqttConfig(request: DescribeMqttConfigRequest): DescribeMqttConfigResponse {
var runtime = new Util.RuntimeOptions{};
return describeMqttConfigWithOptions(request, runtime);
}
model DescribeOssBucketInfoRequest {
bucketEndpoint?: string(name='BucketEndpoint'),
bucketName?: string(name='BucketName'),
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
type?: string(name='Type'),
}
model DescribeOssBucketInfoResponseBody = {
code?: string(name='Code'),
isArchive?: boolean(name='IsArchive'),
isBackToResource?: boolean(name='IsBackToResource'),
isColdArchive?: boolean(name='IsColdArchive'),
isFresh?: boolean(name='IsFresh'),
isSupportServerSideEncryption?: boolean(name='IsSupportServerSideEncryption'),
isVersioning?: boolean(name='IsVersioning'),
message?: string(name='Message'),
pollingInterval?: int32(name='PollingInterval'),
requestId?: string(name='RequestId'),
storageSize?: long(name='StorageSize'),
success?: boolean(name='Success'),
}
model DescribeOssBucketInfoResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeOssBucketInfoResponseBody(name='body'),
}
async function describeOssBucketInfoWithOptions(request: DescribeOssBucketInfoRequest, runtime: Util.RuntimeOptions): DescribeOssBucketInfoResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bucketEndpoint)) {
query['BucketEndpoint'] = request.bucketEndpoint;
}
if (!Util.isUnset(request.bucketName)) {
query['BucketName'] = request.bucketName;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.type)) {
query['Type'] = request.type;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeOssBucketInfo',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeOssBucketInfo(request: DescribeOssBucketInfoRequest): DescribeOssBucketInfoResponse {
var runtime = new Util.RuntimeOptions{};
return describeOssBucketInfoWithOptions(request, runtime);
}
model DescribeOssBucketsRequest {
bucketEndpoint?: string(name='BucketEndpoint'),
securityToken?: string(name='SecurityToken'),
}
model DescribeOssBucketsResponseBody = {
buckets?: {
bucket?: [
{
name?: string(name='Name'),
}
](name='Bucket')
}(name='Buckets'),
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeOssBucketsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeOssBucketsResponseBody(name='body'),
}
async function describeOssBucketsWithOptions(request: DescribeOssBucketsRequest, runtime: Util.RuntimeOptions): DescribeOssBucketsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bucketEndpoint)) {
query['BucketEndpoint'] = request.bucketEndpoint;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeOssBuckets',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeOssBuckets(request: DescribeOssBucketsRequest): DescribeOssBucketsResponse {
var runtime = new Util.RuntimeOptions{};
return describeOssBucketsWithOptions(request, runtime);
}
model DescribePayAsYouGoPriceRequest {
gatewayClass?: string(name='GatewayClass'),
regionId?: string(name='RegionId'),
securityToken?: string(name='SecurityToken'),
}
model DescribePayAsYouGoPriceResponseBody = {
cacheCloudEfficiencySizePrice?: float(name='CacheCloudEfficiencySizePrice'),
cacheCloudSSDSizePrice?: float(name='CacheCloudSSDSizePrice'),
cacheESSDPl1SizePrice?: float(name='CacheESSDPl1SizePrice'),
code?: string(name='Code'),
currency?: string(name='Currency'),
gatewayClassPrice?: float(name='GatewayClassPrice'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribePayAsYouGoPriceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribePayAsYouGoPriceResponseBody(name='body'),
}
async function describePayAsYouGoPriceWithOptions(request: DescribePayAsYouGoPriceRequest, runtime: Util.RuntimeOptions): DescribePayAsYouGoPriceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayClass)) {
query['GatewayClass'] = request.gatewayClass;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribePayAsYouGoPrice',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describePayAsYouGoPrice(request: DescribePayAsYouGoPriceRequest): DescribePayAsYouGoPriceResponse {
var runtime = new Util.RuntimeOptions{};
return describePayAsYouGoPriceWithOptions(request, runtime);
}
model DescribeRegionsRequest {
securityToken?: string(name='SecurityToken'),
}
model DescribeRegionsResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
regions?: {
region?: [
{
regionId?: string(name='RegionId', example='cn-hangzhou'),
}
](name='Region')
}(name='Regions'),
requestId?: string(name='RequestId', example='E09C421A-A175-4D21-8928-ADF5643D15F8'),
success?: boolean(name='Success', example='true'),
}
model DescribeRegionsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeRegionsResponseBody(name='body'),
}
async function describeRegionsWithOptions(request: DescribeRegionsRequest, runtime: Util.RuntimeOptions): DescribeRegionsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeRegions',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeRegions(request: DescribeRegionsRequest): DescribeRegionsResponse {
var runtime = new Util.RuntimeOptions{};
return describeRegionsWithOptions(request, runtime);
}
model DescribeSharesBucketInfoForExpressSyncRequest {
bucketName?: string(name='BucketName', example='bucket***'),
bucketRegion?: string(name='BucketRegion', example='cn-hangzhou'),
securityToken?: string(name='SecurityToken'),
}
model DescribeSharesBucketInfoForExpressSyncResponseBody = {
bucketInfos?: {
bucketInfo?: [
{
bucketName?: string(name='BucketName', example='zy-1m***'),
bucketPrefix?: string(name='BucketPrefix', example='test1'),
bucketRegion?: string(name='BucketRegion', example='cn-hangzhou'),
}
](name='BucketInfo')
}(name='BucketInfos'),
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='29BD52E7-CF30-418F-A240-E15A9351B666'),
success?: boolean(name='Success', example='true'),
}
model DescribeSharesBucketInfoForExpressSyncResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeSharesBucketInfoForExpressSyncResponseBody(name='body'),
}
async function describeSharesBucketInfoForExpressSyncWithOptions(request: DescribeSharesBucketInfoForExpressSyncRequest, runtime: Util.RuntimeOptions): DescribeSharesBucketInfoForExpressSyncResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bucketName)) {
query['BucketName'] = request.bucketName;
}
if (!Util.isUnset(request.bucketRegion)) {
query['BucketRegion'] = request.bucketRegion;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeSharesBucketInfoForExpressSync',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeSharesBucketInfoForExpressSync(request: DescribeSharesBucketInfoForExpressSyncRequest): DescribeSharesBucketInfoForExpressSyncResponse {
var runtime = new Util.RuntimeOptions{};
return describeSharesBucketInfoForExpressSyncWithOptions(request, runtime);
}
model DescribeStorageBundleRequest {
securityToken?: string(name='SecurityToken'),
storageBundleId?: string(name='StorageBundleId', example='sb-0007y2889yyxkuqov***'),
}
model DescribeStorageBundleResponseBody = {
backendBucketRegionId?: string(name='BackendBucketRegionId', example='cn-shanghai'),
code?: string(name='Code', example='200'),
createdTime?: long(name='CreatedTime', example='1657706998'),
description?: string(name='Description'),
message?: string(name='Message', example='successful'),
name?: string(name='Name', example='sdfa***'),
requestId?: string(name='RequestId', example='736C7733-FCED-4AFB-8407-C325F210CE03'),
storageBundleId?: string(name='StorageBundleId', example='sb-000dt67z4ijqfocpy***'),
success?: boolean(name='Success', example='true'),
}
model DescribeStorageBundleResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeStorageBundleResponseBody(name='body'),
}
async function describeStorageBundleWithOptions(request: DescribeStorageBundleRequest, runtime: Util.RuntimeOptions): DescribeStorageBundleResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.storageBundleId)) {
query['StorageBundleId'] = request.storageBundleId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeStorageBundle',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeStorageBundle(request: DescribeStorageBundleRequest): DescribeStorageBundleResponse {
var runtime = new Util.RuntimeOptions{};
return describeStorageBundleWithOptions(request, runtime);
}
model DescribeStorageBundlesRequest {
backendBucketRegionId?: string(name='BackendBucketRegionId', example='cn-hangzhou'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
securityToken?: string(name='SecurityToken'),
}
model DescribeStorageBundlesResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
requestId?: string(name='RequestId', example='1EB4639B-0812-4F2D-AB78-194E67645E357'),
storageBundles?: {
storageBundle?: [
{
backendBucketRegionId?: string(name='BackendBucketRegionId', example='cn-hangzhou'),
createdTime?: long(name='CreatedTime', example='1565750633'),
description?: string(name='Description'),
name?: string(name='Name', example='zy-test***'),
storageBundleId?: string(name='StorageBundleId', example='sb-000ibk4xrlr03qrjr***'),
}
](name='StorageBundle')
}(name='StorageBundles'),
success?: boolean(name='Success', example='true'),
totalCount?: int32(name='TotalCount', example='20'),
}
model DescribeStorageBundlesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeStorageBundlesResponseBody(name='body'),
}
async function describeStorageBundlesWithOptions(request: DescribeStorageBundlesRequest, runtime: Util.RuntimeOptions): DescribeStorageBundlesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.backendBucketRegionId)) {
query['BackendBucketRegionId'] = request.backendBucketRegionId;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeStorageBundles',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeStorageBundles(request: DescribeStorageBundlesRequest): DescribeStorageBundlesResponse {
var runtime = new Util.RuntimeOptions{};
return describeStorageBundlesWithOptions(request, runtime);
}
model DescribeSubscriptionPriceRequest {
cacheCloudEfficiencySize?: long(name='CacheCloudEfficiencySize'),
cacheESSDPl1Size?: long(name='CacheESSDPl1Size'),
cacheSSDSize?: long(name='CacheSSDSize'),
gatewayClass?: string(name='GatewayClass'),
periodQuantity?: int32(name='PeriodQuantity'),
periodUnit?: string(name='PeriodUnit'),
regionId?: string(name='RegionId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeSubscriptionPriceResponseBody = {
code?: string(name='Code'),
currency?: string(name='Currency'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
tradePrice?: float(name='TradePrice'),
}
model DescribeSubscriptionPriceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeSubscriptionPriceResponseBody(name='body'),
}
async function describeSubscriptionPriceWithOptions(request: DescribeSubscriptionPriceRequest, runtime: Util.RuntimeOptions): DescribeSubscriptionPriceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.cacheCloudEfficiencySize)) {
query['CacheCloudEfficiencySize'] = request.cacheCloudEfficiencySize;
}
if (!Util.isUnset(request.cacheESSDPl1Size)) {
query['CacheESSDPl1Size'] = request.cacheESSDPl1Size;
}
if (!Util.isUnset(request.cacheSSDSize)) {
query['CacheSSDSize'] = request.cacheSSDSize;
}
if (!Util.isUnset(request.gatewayClass)) {
query['GatewayClass'] = request.gatewayClass;
}
if (!Util.isUnset(request.periodQuantity)) {
query['PeriodQuantity'] = request.periodQuantity;
}
if (!Util.isUnset(request.periodUnit)) {
query['PeriodUnit'] = request.periodUnit;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeSubscriptionPrice',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeSubscriptionPrice(request: DescribeSubscriptionPriceRequest): DescribeSubscriptionPriceResponse {
var runtime = new Util.RuntimeOptions{};
return describeSubscriptionPriceWithOptions(request, runtime);
}
model DescribeTasksRequest {
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
securityToken?: string(name='SecurityToken'),
targetId?: string(name='TargetId', example='sync-0001xv757xl9sn548***'),
taskId?: string(name='TaskId', example='t-0001xv7je357xl9n***'),
}
model DescribeTasksResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
pageNumber?: int32(name='PageNumber', example='1'),
pageSize?: int32(name='PageSize', example='10'),
requestId?: string(name='RequestId', example='8E9C6D43-4603-4F05-BE76-677A05EDFB7A'),
success?: boolean(name='Success', example='true'),
tasks?: {
simpleTask?: [
{
createdTime?: long(name='CreatedTime', example='1578367229'),
messageKey?: string(name='MessageKey', example='xxxxxxxxxx'),
name?: string(name='Name', example='task.name.operate_fast_sync.delete'),
progress?: int32(name='Progress', example='100'),
relatedResourceId?: string(name='RelatedResourceId'),
stateCode?: string(name='StateCode', example='task.state.completed'),
taskId?: string(name='TaskId', example='t-0001xv7je357xl9n***'),
updatedTime?: long(name='UpdatedTime', example='1578367230'),
}
](name='SimpleTask')
}(name='Tasks'),
totalCount?: int32(name='TotalCount', example='1'),
}
model DescribeTasksResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeTasksResponseBody(name='body'),
}
async function describeTasksWithOptions(request: DescribeTasksRequest, runtime: Util.RuntimeOptions): DescribeTasksResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.targetId)) {
query['TargetId'] = request.targetId;
}
if (!Util.isUnset(request.taskId)) {
query['TaskId'] = request.taskId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeTasks',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeTasks(request: DescribeTasksRequest): DescribeTasksResponse {
var runtime = new Util.RuntimeOptions{};
return describeTasksWithOptions(request, runtime);
}
model DescribeUserBusinessStatusRequest {
securityToken?: string(name='SecurityToken'),
}
model DescribeUserBusinessStatusResponseBody = {
code?: string(name='Code'),
isEnabled?: boolean(name='IsEnabled'),
isIndebted?: boolean(name='IsIndebted'),
isIndebtedOverdue?: boolean(name='IsIndebtedOverdue'),
isRiskControl?: boolean(name='IsRiskControl'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DescribeUserBusinessStatusResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeUserBusinessStatusResponseBody(name='body'),
}
async function describeUserBusinessStatusWithOptions(request: DescribeUserBusinessStatusRequest, runtime: Util.RuntimeOptions): DescribeUserBusinessStatusResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeUserBusinessStatus',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeUserBusinessStatus(request: DescribeUserBusinessStatusRequest): DescribeUserBusinessStatusResponse {
var runtime = new Util.RuntimeOptions{};
return describeUserBusinessStatusWithOptions(request, runtime);
}
model DescribeVSwitchesRequest {
name?: string(name='Name'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
resourceRegionId?: string(name='ResourceRegionId'),
securityToken?: string(name='SecurityToken'),
storageBundleId?: string(name='StorageBundleId'),
vSwitchId?: string(name='VSwitchId'),
vpcId?: string(name='VpcId'),
}
model DescribeVSwitchesResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
totalCount?: int32(name='TotalCount'),
vSwitches?: {
vSwitch?: [
{
availableSelectionInfo?: string(name='AvailableSelectionInfo'),
id?: string(name='Id'),
isDefault?: boolean(name='IsDefault'),
name?: string(name='Name'),
zoneId?: string(name='ZoneId'),
}
](name='VSwitch')
}(name='VSwitches'),
}
model DescribeVSwitchesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeVSwitchesResponseBody(name='body'),
}
async function describeVSwitchesWithOptions(request: DescribeVSwitchesRequest, runtime: Util.RuntimeOptions): DescribeVSwitchesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.resourceRegionId)) {
query['ResourceRegionId'] = request.resourceRegionId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.storageBundleId)) {
query['StorageBundleId'] = request.storageBundleId;
}
if (!Util.isUnset(request.vSwitchId)) {
query['VSwitchId'] = request.vSwitchId;
}
if (!Util.isUnset(request.vpcId)) {
query['VpcId'] = request.vpcId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeVSwitches',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeVSwitches(request: DescribeVSwitchesRequest): DescribeVSwitchesResponse {
var runtime = new Util.RuntimeOptions{};
return describeVSwitchesWithOptions(request, runtime);
}
model DescribeVpcsRequest {
name?: string(name='Name'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
resourceRegionId?: string(name='ResourceRegionId'),
securityToken?: string(name='SecurityToken'),
storageBundleId?: string(name='StorageBundleId'),
vpcId?: string(name='VpcId'),
}
model DescribeVpcsResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
pageNumber?: int32(name='PageNumber'),
pageSize?: int32(name='PageSize'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
totalCount?: int32(name='TotalCount'),
vpcs?: {
vpc?: [
{
cidrBlock?: string(name='CidrBlock'),
id?: string(name='Id'),
isDefault?: boolean(name='IsDefault'),
name?: string(name='Name'),
}
](name='Vpc')
}(name='Vpcs'),
}
model DescribeVpcsResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeVpcsResponseBody(name='body'),
}
async function describeVpcsWithOptions(request: DescribeVpcsRequest, runtime: Util.RuntimeOptions): DescribeVpcsResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.pageNumber)) {
query['PageNumber'] = request.pageNumber;
}
if (!Util.isUnset(request.pageSize)) {
query['PageSize'] = request.pageSize;
}
if (!Util.isUnset(request.resourceRegionId)) {
query['ResourceRegionId'] = request.resourceRegionId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.storageBundleId)) {
query['StorageBundleId'] = request.storageBundleId;
}
if (!Util.isUnset(request.vpcId)) {
query['VpcId'] = request.vpcId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeVpcs',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeVpcs(request: DescribeVpcsRequest): DescribeVpcsResponse {
var runtime = new Util.RuntimeOptions{};
return describeVpcsWithOptions(request, runtime);
}
model DescribeZonesRequest {
regionId?: string(name='RegionId'),
securityToken?: string(name='SecurityToken'),
}
model DescribeZonesResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
zones?: {
zone?: [
{
zoneId?: string(name='ZoneId'),
}
](name='Zone')
}(name='Zones'),
}
model DescribeZonesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DescribeZonesResponseBody(name='body'),
}
async function describeZonesWithOptions(request: DescribeZonesRequest, runtime: Util.RuntimeOptions): DescribeZonesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DescribeZones',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function describeZones(request: DescribeZonesRequest): DescribeZonesResponse {
var runtime = new Util.RuntimeOptions{};
return describeZonesWithOptions(request, runtime);
}
model DisableGatewayLoggingRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwb***'),
securityToken?: string(name='SecurityToken'),
}
model DisableGatewayLoggingResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='25288205-A591-4AA9-ACF8-427E8727A9D3'),
success?: boolean(name='Success', example='true'),
}
model DisableGatewayLoggingResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DisableGatewayLoggingResponseBody(name='body'),
}
async function disableGatewayLoggingWithOptions(request: DisableGatewayLoggingRequest, runtime: Util.RuntimeOptions): DisableGatewayLoggingResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DisableGatewayLogging',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function disableGatewayLogging(request: DisableGatewayLoggingRequest): DisableGatewayLoggingResponse {
var runtime = new Util.RuntimeOptions{};
return disableGatewayLoggingWithOptions(request, runtime);
}
model DisableGatewayNFSVersionRequest {
gatewayId?: string(name='GatewayId'),
NFSVersion?: string(name='NFSVersion'),
securityToken?: string(name='SecurityToken'),
}
model DisableGatewayNFSVersionResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model DisableGatewayNFSVersionResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: DisableGatewayNFSVersionResponseBody(name='body'),
}
async function disableGatewayNFSVersionWithOptions(request: DisableGatewayNFSVersionRequest, runtime: Util.RuntimeOptions): DisableGatewayNFSVersionResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.NFSVersion)) {
query['NFSVersion'] = request.NFSVersion;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'DisableGatewayNFSVersion',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function disableGatewayNFSVersion(request: DisableGatewayNFSVersionRequest): DisableGatewayNFSVersionResponse {
var runtime = new Util.RuntimeOptions{};
return disableGatewayNFSVersionWithOptions(request, runtime);
}
model EnableGatewayIpv6Request {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model EnableGatewayIpv6ResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model EnableGatewayIpv6Response = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: EnableGatewayIpv6ResponseBody(name='body'),
}
async function enableGatewayIpv6WithOptions(request: EnableGatewayIpv6Request, runtime: Util.RuntimeOptions): EnableGatewayIpv6Response {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'EnableGatewayIpv6',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function enableGatewayIpv6(request: EnableGatewayIpv6Request): EnableGatewayIpv6Response {
var runtime = new Util.RuntimeOptions{};
return enableGatewayIpv6WithOptions(request, runtime);
}
model EnableGatewayLoggingRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbv***'),
securityToken?: string(name='SecurityToken'),
}
model EnableGatewayLoggingResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='CAE39768-CE96-4E16-A9F7-1FF9AE8E3FBF'),
success?: boolean(name='Success', example='true'),
}
model EnableGatewayLoggingResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: EnableGatewayLoggingResponseBody(name='body'),
}
async function enableGatewayLoggingWithOptions(request: EnableGatewayLoggingRequest, runtime: Util.RuntimeOptions): EnableGatewayLoggingResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'EnableGatewayLogging',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function enableGatewayLogging(request: EnableGatewayLoggingRequest): EnableGatewayLoggingResponse {
var runtime = new Util.RuntimeOptions{};
return enableGatewayLoggingWithOptions(request, runtime);
}
model ExpandCacheDiskRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
localFilePath?: string(name='LocalFilePath', example='/dev/vdb'),
newSizeInGB?: int32(name='NewSizeInGB', example='101'),
securityToken?: string(name='SecurityToken'),
}
model ExpandCacheDiskResponseBody = {
buyURL?: string(name='BuyURL', example='https://common-buy.aliyun.com/?commodityCode=hcs_sgw_csg_pre&request={"gateway_id":"gw-0007va9bnidei3s8a***”,”directBuy":"false","gateway_class":"standard","cache_cloud_efficiency_size":0}®ionId=cn-hangzhou#/buy'),
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='F8B59F29-453D-49BF-8673-EEB8F9F2D5C6'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000eg44nmxbsh3qk3***'),
}
model ExpandCacheDiskResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ExpandCacheDiskResponseBody(name='body'),
}
async function expandCacheDiskWithOptions(request: ExpandCacheDiskRequest, runtime: Util.RuntimeOptions): ExpandCacheDiskResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.localFilePath)) {
query['LocalFilePath'] = request.localFilePath;
}
if (!Util.isUnset(request.newSizeInGB)) {
query['NewSizeInGB'] = request.newSizeInGB;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ExpandCacheDisk',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function expandCacheDisk(request: ExpandCacheDiskRequest): ExpandCacheDiskResponse {
var runtime = new Util.RuntimeOptions{};
return expandCacheDiskWithOptions(request, runtime);
}
model ExpandGatewayFileShareRequest {
gatewayId?: string(name='GatewayId'),
indexId?: string(name='IndexId'),
}
model ExpandGatewayFileShareResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model ExpandGatewayFileShareResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ExpandGatewayFileShareResponseBody(name='body'),
}
async function expandGatewayFileShareWithOptions(request: ExpandGatewayFileShareRequest, runtime: Util.RuntimeOptions): ExpandGatewayFileShareResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ExpandGatewayFileShare',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function expandGatewayFileShare(request: ExpandGatewayFileShareRequest): ExpandGatewayFileShareResponse {
var runtime = new Util.RuntimeOptions{};
return expandGatewayFileShareWithOptions(request, runtime);
}
model ExpandGatewayNetworkBandwidthRequest {
gatewayId?: string(name='GatewayId'),
newNetworkBandwidth?: int32(name='NewNetworkBandwidth'),
securityToken?: string(name='SecurityToken'),
}
model ExpandGatewayNetworkBandwidthResponseBody = {
buyURL?: string(name='BuyURL'),
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model ExpandGatewayNetworkBandwidthResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ExpandGatewayNetworkBandwidthResponseBody(name='body'),
}
async function expandGatewayNetworkBandwidthWithOptions(request: ExpandGatewayNetworkBandwidthRequest, runtime: Util.RuntimeOptions): ExpandGatewayNetworkBandwidthResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.newNetworkBandwidth)) {
query['NewNetworkBandwidth'] = request.newNetworkBandwidth;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ExpandGatewayNetworkBandwidth',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function expandGatewayNetworkBandwidth(request: ExpandGatewayNetworkBandwidthRequest): ExpandGatewayNetworkBandwidthResponse {
var runtime = new Util.RuntimeOptions{};
return expandGatewayNetworkBandwidthWithOptions(request, runtime);
}
model GenerateGatewayTokenRequest {
gatewayId?: string(name='GatewayId', example='gw-000do8l6anyk2iklv***'),
securityToken?: string(name='SecurityToken'),
}
model GenerateGatewayTokenResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='8E9C6D43-4603-4F05-BE76-677A05EDFB7A'),
success?: boolean(name='Success', example='true'),
token?: string(name='Token', example='xxxxx'),
}
model GenerateGatewayTokenResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: GenerateGatewayTokenResponseBody(name='body'),
}
async function generateGatewayTokenWithOptions(request: GenerateGatewayTokenRequest, runtime: Util.RuntimeOptions): GenerateGatewayTokenResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'GenerateGatewayToken',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function generateGatewayToken(request: GenerateGatewayTokenRequest): GenerateGatewayTokenResponse {
var runtime = new Util.RuntimeOptions{};
return generateGatewayTokenWithOptions(request, runtime);
}
model GenerateMqttTokenRequest {
clientUUID?: string(name='ClientUUID'),
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
}
model GenerateMqttTokenResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
mqttToken?: string(name='MqttToken'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model GenerateMqttTokenResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: GenerateMqttTokenResponseBody(name='body'),
}
async function generateMqttTokenWithOptions(request: GenerateMqttTokenRequest, runtime: Util.RuntimeOptions): GenerateMqttTokenResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientUUID)) {
query['ClientUUID'] = request.clientUUID;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'GenerateMqttToken',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function generateMqttToken(request: GenerateMqttTokenRequest): GenerateMqttTokenResponse {
var runtime = new Util.RuntimeOptions{};
return generateMqttTokenWithOptions(request, runtime);
}
model GenerateStsTokenRequest {
expireInSeconds?: long(name='ExpireInSeconds'),
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
tokenType?: string(name='TokenType'),
}
model GenerateStsTokenResponseBody = {
accessKeyId?: string(name='AccessKeyId'),
accessKeySecret?: string(name='AccessKeySecret'),
code?: string(name='Code'),
environment?: string(name='Environment'),
expiration?: string(name='Expiration'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
securityToken?: string(name='SecurityToken'),
success?: boolean(name='Success'),
supportBundleTarget?: string(name='SupportBundleTarget'),
}
model GenerateStsTokenResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: GenerateStsTokenResponseBody(name='body'),
}
async function generateStsTokenWithOptions(request: GenerateStsTokenRequest, runtime: Util.RuntimeOptions): GenerateStsTokenResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.expireInSeconds)) {
query['ExpireInSeconds'] = request.expireInSeconds;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.tokenType)) {
query['TokenType'] = request.tokenType;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'GenerateStsToken',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function generateStsToken(request: GenerateStsTokenRequest): GenerateStsTokenResponse {
var runtime = new Util.RuntimeOptions{};
return generateStsTokenWithOptions(request, runtime);
}
model HandleGatewayAutoPlanRequest {
cancel?: boolean(name='Cancel'),
delayHours?: int32(name='DelayHours'),
gatewayId?: string(name='GatewayId'),
planId?: string(name='PlanId'),
securityToken?: string(name='SecurityToken'),
}
model HandleGatewayAutoPlanResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model HandleGatewayAutoPlanResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: HandleGatewayAutoPlanResponseBody(name='body'),
}
async function handleGatewayAutoPlanWithOptions(request: HandleGatewayAutoPlanRequest, runtime: Util.RuntimeOptions): HandleGatewayAutoPlanResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.cancel)) {
query['Cancel'] = request.cancel;
}
if (!Util.isUnset(request.delayHours)) {
query['DelayHours'] = request.delayHours;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.planId)) {
query['PlanId'] = request.planId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'HandleGatewayAutoPlan',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function handleGatewayAutoPlan(request: HandleGatewayAutoPlanRequest): HandleGatewayAutoPlanResponse {
var runtime = new Util.RuntimeOptions{};
return handleGatewayAutoPlanWithOptions(request, runtime);
}
model ListTagResourcesRequest {
nextToken?: string(name='NextToken', example='212db86sca4384811e0b5e8707ec21345'),
regionId?: string(name='RegionId', example='cn-hangzhou'),
resourceId?: [ string ](name='ResourceId', example='gw-uf6wjk5xxxxxxx'),
resourceRegionId?: string(name='ResourceRegionId'),
resourceType?: string(name='ResourceType', example='GATEWAY'),
securityToken?: string(name='SecurityToken'),
tag?: [
{
key?: string(name='Key', example='testkey1'),
value?: string(name='Value', example='testvalue1'),
}
](name='Tag'),
}
model ListTagResourcesResponseBody = {
nextToken?: string(name='NextToken', example='212db86sca4384811e0b5e8707ec21345'),
requestId?: string(name='RequestId', example='47A514A1-4B77-4E30-B4C5-2A880650B3FD'),
tagResources?: {
tagResource?: [
{
resourceId?: string(name='ResourceId', example='47A514A1-4B77-4E30-B4C5-2A880650B3FD'),
resourceType?: string(name='ResourceType', example='ALIYUN::HCS_SGW::GATEWAY'),
tagKey?: string(name='TagKey', example='testkey1'),
tagValue?: string(name='TagValue', example='testvalue1'),
}
](name='TagResource')
}(name='TagResources'),
}
model ListTagResourcesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ListTagResourcesResponseBody(name='body'),
}
async function listTagResourcesWithOptions(request: ListTagResourcesRequest, runtime: Util.RuntimeOptions): ListTagResourcesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.nextToken)) {
query['NextToken'] = request.nextToken;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceId)) {
query['ResourceId'] = request.resourceId;
}
if (!Util.isUnset(request.resourceRegionId)) {
query['ResourceRegionId'] = request.resourceRegionId;
}
if (!Util.isUnset(request.resourceType)) {
query['ResourceType'] = request.resourceType;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.tag)) {
query['Tag'] = request.tag;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ListTagResources',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function listTagResources(request: ListTagResourcesRequest): ListTagResourcesResponse {
var runtime = new Util.RuntimeOptions{};
return listTagResourcesWithOptions(request, runtime);
}
model ModifyGatewayRequest {
description?: string(name='Description'),
gatewayId?: string(name='GatewayId', example='gw-0001xv7je3580031y***'),
name?: string(name='Name', example='alex***'),
securityToken?: string(name='SecurityToken'),
}
model ModifyGatewayResponseBody = {
code?: string(name='Code', example='200'),
gatewayId?: string(name='GatewayId', example='gw-0001xv7je3580031y***'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='220E7407-DF77-428D-8955-B02CF8F82D07'),
success?: boolean(name='Success', example='true'),
}
model ModifyGatewayResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyGatewayResponseBody(name='body'),
}
async function modifyGatewayWithOptions(request: ModifyGatewayRequest, runtime: Util.RuntimeOptions): ModifyGatewayResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.description)) {
query['Description'] = request.description;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyGateway',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function modifyGateway(request: ModifyGatewayRequest): ModifyGatewayResponse {
var runtime = new Util.RuntimeOptions{};
return modifyGatewayWithOptions(request, runtime);
}
model ModifyGatewayBlockVolumeRequest {
cacheConfig?: string(name='CacheConfig'),
gatewayId?: string(name='GatewayId'),
indexId?: string(name='IndexId'),
securityToken?: string(name='SecurityToken'),
}
model ModifyGatewayBlockVolumeResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model ModifyGatewayBlockVolumeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyGatewayBlockVolumeResponseBody(name='body'),
}
async function modifyGatewayBlockVolumeWithOptions(request: ModifyGatewayBlockVolumeRequest, runtime: Util.RuntimeOptions): ModifyGatewayBlockVolumeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.cacheConfig)) {
query['CacheConfig'] = request.cacheConfig;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyGatewayBlockVolume',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function modifyGatewayBlockVolume(request: ModifyGatewayBlockVolumeRequest): ModifyGatewayBlockVolumeResponse {
var runtime = new Util.RuntimeOptions{};
return modifyGatewayBlockVolumeWithOptions(request, runtime);
}
model ModifyGatewayClassRequest {
gatewayClass?: string(name='GatewayClass', example='Enhanced'),
gatewayId?: string(name='GatewayId', example='gw-0001xv7580031yzun***'),
securityToken?: string(name='SecurityToken'),
}
model ModifyGatewayClassResponseBody = {
buyURL?: string(name='BuyURL', example='https://common-buy.aliyun.com/?commodityCode=hcs_sgw_csg_pre&orderType=UPGRADE&instanceId=gw-000c6hshwukjwc7e1***#/upgrade'),
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='395B1136-982E-4F95-BDCE-7323FFEF499E'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0001xv7je3580bx6v***'),
}
model ModifyGatewayClassResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyGatewayClassResponseBody(name='body'),
}
async function modifyGatewayClassWithOptions(request: ModifyGatewayClassRequest, runtime: Util.RuntimeOptions): ModifyGatewayClassResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayClass)) {
query['GatewayClass'] = request.gatewayClass;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyGatewayClass',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function modifyGatewayClass(request: ModifyGatewayClassRequest): ModifyGatewayClassResponse {
var runtime = new Util.RuntimeOptions{};
return modifyGatewayClassWithOptions(request, runtime);
}
model ModifyGatewayFileShareRequest {
cacheConfig?: string(name='CacheConfig'),
gatewayId?: string(name='GatewayId'),
indexId?: string(name='IndexId'),
securityToken?: string(name='SecurityToken'),
}
model ModifyGatewayFileShareResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model ModifyGatewayFileShareResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyGatewayFileShareResponseBody(name='body'),
}
async function modifyGatewayFileShareWithOptions(request: ModifyGatewayFileShareRequest, runtime: Util.RuntimeOptions): ModifyGatewayFileShareResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.cacheConfig)) {
query['CacheConfig'] = request.cacheConfig;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyGatewayFileShare',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function modifyGatewayFileShare(request: ModifyGatewayFileShareRequest): ModifyGatewayFileShareResponse {
var runtime = new Util.RuntimeOptions{};
return modifyGatewayFileShareWithOptions(request, runtime);
}
model ModifyGatewayFileShareWatermarkRequest {
gatewayId?: string(name='GatewayId'),
indexId?: string(name='IndexId'),
securityToken?: string(name='SecurityToken'),
watermark?: int32(name='Watermark'),
}
model ModifyGatewayFileShareWatermarkResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model ModifyGatewayFileShareWatermarkResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyGatewayFileShareWatermarkResponseBody(name='body'),
}
async function modifyGatewayFileShareWatermarkWithOptions(request: ModifyGatewayFileShareWatermarkRequest, runtime: Util.RuntimeOptions): ModifyGatewayFileShareWatermarkResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.watermark)) {
query['Watermark'] = request.watermark;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyGatewayFileShareWatermark',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function modifyGatewayFileShareWatermark(request: ModifyGatewayFileShareWatermarkRequest): ModifyGatewayFileShareWatermarkResponse {
var runtime = new Util.RuntimeOptions{};
return modifyGatewayFileShareWatermarkWithOptions(request, runtime);
}
model ModifyStorageBundleRequest {
description?: string(name='Description'),
name?: string(name='Name', example='alex-123***'),
securityToken?: string(name='SecurityToken'),
storageBundleId?: string(name='StorageBundleId', example='sb-000ibk4xrlr03qrjr***'),
}
model ModifyStorageBundleResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='70EACC9C-D07A-4A34-ADA4-77506C42777'),
storageBundleId?: string(name='StorageBundleId', example='sb-000ibk4xrlr03qr***'),
success?: boolean(name='Success', example='true'),
}
model ModifyStorageBundleResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ModifyStorageBundleResponseBody(name='body'),
}
async function modifyStorageBundleWithOptions(request: ModifyStorageBundleRequest, runtime: Util.RuntimeOptions): ModifyStorageBundleResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.description)) {
query['Description'] = request.description;
}
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.storageBundleId)) {
query['StorageBundleId'] = request.storageBundleId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ModifyStorageBundle',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function modifyStorageBundle(request: ModifyStorageBundleRequest): ModifyStorageBundleResponse {
var runtime = new Util.RuntimeOptions{};
return modifyStorageBundleWithOptions(request, runtime);
}
model OpenSgwServiceResponseBody = {
orderId?: string(name='OrderId'),
requestId?: string(name='RequestId'),
}
model OpenSgwServiceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: OpenSgwServiceResponseBody(name='body'),
}
async function openSgwServiceWithOptions(runtime: Util.RuntimeOptions): OpenSgwServiceResponse {
var req = new OpenApi.OpenApiRequest{};
var params = new OpenApi.Params{
action = 'OpenSgwService',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function openSgwService(): OpenSgwServiceResponse {
var runtime = new Util.RuntimeOptions{};
return openSgwServiceWithOptions(runtime);
}
model OperateGatewayRequest {
gatewayId?: string(name='GatewayId'),
operateAction?: string(name='OperateAction'),
params?: string(name='Params'),
securityToken?: string(name='SecurityToken'),
}
model OperateGatewayResponseBody = {
buyURL?: string(name='BuyURL'),
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model OperateGatewayResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: OperateGatewayResponseBody(name='body'),
}
async function operateGatewayWithOptions(request: OperateGatewayRequest, runtime: Util.RuntimeOptions): OperateGatewayResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.operateAction)) {
query['OperateAction'] = request.operateAction;
}
if (!Util.isUnset(request.params)) {
query['Params'] = request.params;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'OperateGateway',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function operateGateway(request: OperateGatewayRequest): OperateGatewayResponse {
var runtime = new Util.RuntimeOptions{};
return operateGatewayWithOptions(request, runtime);
}
model ReleaseServiceRequest {
securityToken?: string(name='SecurityToken'),
}
model ReleaseServiceResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model ReleaseServiceResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ReleaseServiceResponseBody(name='body'),
}
async function releaseServiceWithOptions(request: ReleaseServiceRequest, runtime: Util.RuntimeOptions): ReleaseServiceResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ReleaseService',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function releaseService(request: ReleaseServiceRequest): ReleaseServiceResponse {
var runtime = new Util.RuntimeOptions{};
return releaseServiceWithOptions(request, runtime);
}
model RemoveSharesFromExpressSyncRequest {
expressSyncId?: string(name='ExpressSyncId', example='sync-0001xv7je357xn8tr***'),
gatewayShares?: string(name='GatewayShares', example='{"gw-000gwgp0j3jp8cb3t***":"share1,share2","gw-0001b2otnkdzte62j***":"weekly"}'),
securityToken?: string(name='SecurityToken'),
}
model RemoveSharesFromExpressSyncResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='1EDBC004-6B1C-4511-ACF5-0B4875BA3B22'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0001xv7je357xr6ql***'),
}
model RemoveSharesFromExpressSyncResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: RemoveSharesFromExpressSyncResponseBody(name='body'),
}
async function removeSharesFromExpressSyncWithOptions(request: RemoveSharesFromExpressSyncRequest, runtime: Util.RuntimeOptions): RemoveSharesFromExpressSyncResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.expressSyncId)) {
query['ExpressSyncId'] = request.expressSyncId;
}
if (!Util.isUnset(request.gatewayShares)) {
query['GatewayShares'] = request.gatewayShares;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'RemoveSharesFromExpressSync',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function removeSharesFromExpressSync(request: RemoveSharesFromExpressSyncRequest): RemoveSharesFromExpressSyncResponse {
var runtime = new Util.RuntimeOptions{};
return removeSharesFromExpressSyncWithOptions(request, runtime);
}
model RemoveTagsFromGatewayRequest {
gatewayId?: string(name='GatewayId'),
securityToken?: string(name='SecurityToken'),
tags?: string(name='Tags'),
}
model RemoveTagsFromGatewayResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model RemoveTagsFromGatewayResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: RemoveTagsFromGatewayResponseBody(name='body'),
}
async function removeTagsFromGatewayWithOptions(request: RemoveTagsFromGatewayRequest, runtime: Util.RuntimeOptions): RemoveTagsFromGatewayResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.tags)) {
query['Tags'] = request.tags;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'RemoveTagsFromGateway',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function removeTagsFromGateway(request: RemoveTagsFromGatewayRequest): RemoveTagsFromGatewayResponse {
var runtime = new Util.RuntimeOptions{};
return removeTagsFromGatewayWithOptions(request, runtime);
}
model ReportBlockVolumesRequest {
clientUUID?: string(name='ClientUUID'),
gatewayId?: string(name='GatewayId'),
info?: string(name='Info'),
securityToken?: string(name='SecurityToken'),
}
model ReportBlockVolumesResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model ReportBlockVolumesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ReportBlockVolumesResponseBody(name='body'),
}
async function reportBlockVolumesWithOptions(request: ReportBlockVolumesRequest, runtime: Util.RuntimeOptions): ReportBlockVolumesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientUUID)) {
query['ClientUUID'] = request.clientUUID;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.info)) {
query['Info'] = request.info;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ReportBlockVolumes',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function reportBlockVolumes(request: ReportBlockVolumesRequest): ReportBlockVolumesResponse {
var runtime = new Util.RuntimeOptions{};
return reportBlockVolumesWithOptions(request, runtime);
}
model ReportFileSharesRequest {
clientUUID?: string(name='ClientUUID'),
gatewayId?: string(name='GatewayId'),
info?: string(name='Info'),
securityToken?: string(name='SecurityToken'),
}
model ReportFileSharesResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model ReportFileSharesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ReportFileSharesResponseBody(name='body'),
}
async function reportFileSharesWithOptions(request: ReportFileSharesRequest, runtime: Util.RuntimeOptions): ReportFileSharesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientUUID)) {
query['ClientUUID'] = request.clientUUID;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.info)) {
query['Info'] = request.info;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ReportFileShares',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function reportFileShares(request: ReportFileSharesRequest): ReportFileSharesResponse {
var runtime = new Util.RuntimeOptions{};
return reportFileSharesWithOptions(request, runtime);
}
model ReportGatewayInfoRequest {
clientUUID?: string(name='ClientUUID', example='28c07861-a93b-4aa2-ae3a-3f7b7e7f6184'),
gatewayId?: string(name='GatewayId', example='gw-1234567890abcd'),
gatewayStatus?: string(name='GatewayStatus', example='running'),
info?: string(name='Info', example='{"ReadIOPS":16,"OSSStorageUsage":2331983505,"CPUSys":4,"CPUUser":24,"CPUIdle":72,"DiskWrite":16384,"NetRecv":3071,"NetSend":5525,"UsedCacheSize":181395456,"WriteIOPS":4,"MemUsed":4340056064,"DiskRead":348160,"MemFree":498073600}'),
securityToken?: string(name='SecurityToken'),
time?: long(name='Time', example='1528436020'),
}
model ReportGatewayInfoResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='5C109361-5F29-467D-D4A3-1131A8DA1A72'),
success?: boolean(name='Success', example='true'),
}
model ReportGatewayInfoResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ReportGatewayInfoResponseBody(name='body'),
}
async function reportGatewayInfoWithOptions(request: ReportGatewayInfoRequest, runtime: Util.RuntimeOptions): ReportGatewayInfoResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientUUID)) {
query['ClientUUID'] = request.clientUUID;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.gatewayStatus)) {
query['GatewayStatus'] = request.gatewayStatus;
}
if (!Util.isUnset(request.info)) {
query['Info'] = request.info;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.time)) {
query['Time'] = request.time;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ReportGatewayInfo',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function reportGatewayInfo(request: ReportGatewayInfoRequest): ReportGatewayInfoResponse {
var runtime = new Util.RuntimeOptions{};
return reportGatewayInfoWithOptions(request, runtime);
}
model ReportGatewayUsageRequest {
clientUUID?: string(name='ClientUUID', example='28c07861-a93b-4aa2-ae3a-3f7b7e7f6184'),
gatewayId?: string(name='GatewayId', example='gw-1234567890abcd'),
securityToken?: string(name='SecurityToken'),
usage?: string(name='Usage', example='{"VolumeCount":5,"NfsCount":2,"CacheCapacity":123456789000,"CifsCount":3}'),
}
model ReportGatewayUsageResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='5C109361-5F29-467D-D4A3-1131A8DA1A72'),
success?: boolean(name='Success', example='true'),
}
model ReportGatewayUsageResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ReportGatewayUsageResponseBody(name='body'),
}
async function reportGatewayUsageWithOptions(request: ReportGatewayUsageRequest, runtime: Util.RuntimeOptions): ReportGatewayUsageResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientUUID)) {
query['ClientUUID'] = request.clientUUID;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.usage)) {
query['Usage'] = request.usage;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ReportGatewayUsage',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function reportGatewayUsage(request: ReportGatewayUsageRequest): ReportGatewayUsageResponse {
var runtime = new Util.RuntimeOptions{};
return reportGatewayUsageWithOptions(request, runtime);
}
model ResetGatewayPasswordRequest {
gatewayId?: string(name='GatewayId'),
password?: string(name='Password'),
securityToken?: string(name='SecurityToken'),
username?: string(name='Username'),
}
model ResetGatewayPasswordResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model ResetGatewayPasswordResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ResetGatewayPasswordResponseBody(name='body'),
}
async function resetGatewayPasswordWithOptions(request: ResetGatewayPasswordRequest, runtime: Util.RuntimeOptions): ResetGatewayPasswordResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.password)) {
query['Password'] = request.password;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.username)) {
query['Username'] = request.username;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ResetGatewayPassword',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function resetGatewayPassword(request: ResetGatewayPasswordRequest): ResetGatewayPasswordResponse {
var runtime = new Util.RuntimeOptions{};
return resetGatewayPasswordWithOptions(request, runtime);
}
model RestartFileSharesRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
securityToken?: string(name='SecurityToken'),
shareProtocol?: string(name='ShareProtocol', example='NFS'),
}
model RestartFileSharesResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='89398CFB-4EB6-4C7E-BB3C-EF213AC8FA**'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000czaedx5koz578v***'),
}
model RestartFileSharesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: RestartFileSharesResponseBody(name='body'),
}
async function restartFileSharesWithOptions(request: RestartFileSharesRequest, runtime: Util.RuntimeOptions): RestartFileSharesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.shareProtocol)) {
query['ShareProtocol'] = request.shareProtocol;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'RestartFileShares',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function restartFileShares(request: RestartFileSharesRequest): RestartFileSharesResponse {
var runtime = new Util.RuntimeOptions{};
return restartFileSharesWithOptions(request, runtime);
}
model SetGatewayADInfoRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbv****'),
isEnabled?: boolean(name='IsEnabled', example='true'),
password?: string(name='Password', example='12****'),
securityToken?: string(name='SecurityToken'),
serverIp?: string(name='ServerIp', example='12.12.x.x'),
username?: string(name='Username', example='ale****'),
}
model SetGatewayADInfoResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='89398CFB-4EB6-4C7E-BB3C-EF213AC8FA**'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000c6hshwukkcfn****'),
}
model SetGatewayADInfoResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: SetGatewayADInfoResponseBody(name='body'),
}
async function setGatewayADInfoWithOptions(request: SetGatewayADInfoRequest, runtime: Util.RuntimeOptions): SetGatewayADInfoResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.isEnabled)) {
query['IsEnabled'] = request.isEnabled;
}
if (!Util.isUnset(request.password)) {
query['Password'] = request.password;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.serverIp)) {
query['ServerIp'] = request.serverIp;
}
if (!Util.isUnset(request.username)) {
query['Username'] = request.username;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'SetGatewayADInfo',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function setGatewayADInfo(request: SetGatewayADInfoRequest): SetGatewayADInfoResponse {
var runtime = new Util.RuntimeOptions{};
return setGatewayADInfoWithOptions(request, runtime);
}
model SetGatewayAutoUpgradeConfigurationRequest {
autoUpgradeEndHour?: int32(name='AutoUpgradeEndHour'),
autoUpgradeStartHour?: int32(name='AutoUpgradeStartHour'),
gatewayId?: string(name='GatewayId'),
isAutoUpgrade?: boolean(name='IsAutoUpgrade'),
securityToken?: string(name='SecurityToken'),
}
model SetGatewayAutoUpgradeConfigurationResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model SetGatewayAutoUpgradeConfigurationResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: SetGatewayAutoUpgradeConfigurationResponseBody(name='body'),
}
async function setGatewayAutoUpgradeConfigurationWithOptions(request: SetGatewayAutoUpgradeConfigurationRequest, runtime: Util.RuntimeOptions): SetGatewayAutoUpgradeConfigurationResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.autoUpgradeEndHour)) {
query['AutoUpgradeEndHour'] = request.autoUpgradeEndHour;
}
if (!Util.isUnset(request.autoUpgradeStartHour)) {
query['AutoUpgradeStartHour'] = request.autoUpgradeStartHour;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.isAutoUpgrade)) {
query['IsAutoUpgrade'] = request.isAutoUpgrade;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'SetGatewayAutoUpgradeConfiguration',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function setGatewayAutoUpgradeConfiguration(request: SetGatewayAutoUpgradeConfigurationRequest): SetGatewayAutoUpgradeConfigurationResponse {
var runtime = new Util.RuntimeOptions{};
return setGatewayAutoUpgradeConfigurationWithOptions(request, runtime);
}
model SetGatewayDNSRequest {
dnsServer?: string(name='DnsServer', example='100.100.XX.XX,100.100.XX.XX'),
gatewayId?: string(name='GatewayId', example='gw-000c6hshwukkbryp****'),
securityToken?: string(name='SecurityToken'),
}
model SetGatewayDNSResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='89398CFB-4EB6-4C7E-BB3C-EF213AC8FA**'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000czaedx5koz578****'),
}
model SetGatewayDNSResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: SetGatewayDNSResponseBody(name='body'),
}
async function setGatewayDNSWithOptions(request: SetGatewayDNSRequest, runtime: Util.RuntimeOptions): SetGatewayDNSResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.dnsServer)) {
query['DnsServer'] = request.dnsServer;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'SetGatewayDNS',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function setGatewayDNS(request: SetGatewayDNSRequest): SetGatewayDNSResponse {
var runtime = new Util.RuntimeOptions{};
return setGatewayDNSWithOptions(request, runtime);
}
model SetGatewayLDAPInfoRequest {
baseDN?: string(name='BaseDN', example='dc=sgwt***,dc=local'),
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbv****'),
isEnabled?: boolean(name='IsEnabled', example='true'),
isTls?: boolean(name='IsTls', example='true'),
password?: string(name='Password', example='123***'),
rootDN?: string(name='RootDN', example='cn=admin,dc=sgwt***,dc=local'),
securityToken?: string(name='SecurityToken'),
serverIp?: string(name='ServerIp', example='47.101.59.188'),
}
model SetGatewayLDAPInfoResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='2D1834A3-5EF2-46E2-97F7-C9F0C264C1**'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000eg44nmxbsyd9a****'),
}
model SetGatewayLDAPInfoResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: SetGatewayLDAPInfoResponseBody(name='body'),
}
async function setGatewayLDAPInfoWithOptions(request: SetGatewayLDAPInfoRequest, runtime: Util.RuntimeOptions): SetGatewayLDAPInfoResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.baseDN)) {
query['BaseDN'] = request.baseDN;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.isEnabled)) {
query['IsEnabled'] = request.isEnabled;
}
if (!Util.isUnset(request.isTls)) {
query['IsTls'] = request.isTls;
}
if (!Util.isUnset(request.password)) {
query['Password'] = request.password;
}
if (!Util.isUnset(request.rootDN)) {
query['RootDN'] = request.rootDN;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.serverIp)) {
query['ServerIp'] = request.serverIp;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'SetGatewayLDAPInfo',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function setGatewayLDAPInfo(request: SetGatewayLDAPInfoRequest): SetGatewayLDAPInfoResponse {
var runtime = new Util.RuntimeOptions{};
return setGatewayLDAPInfoWithOptions(request, runtime);
}
model SwitchCSGClientsReverseSyncConfigurationRequest {
clientIds?: [ string ](name='ClientIds'),
clientRegionId?: string(name='ClientRegionId'),
isReverseSync?: boolean(name='IsReverseSync'),
reverseSyncInternalSecond?: int32(name='ReverseSyncInternalSecond'),
securityToken?: string(name='SecurityToken'),
}
model SwitchCSGClientsReverseSyncConfigurationShrinkRequest {
clientIdsShrink?: string(name='ClientIds'),
clientRegionId?: string(name='ClientRegionId'),
isReverseSync?: boolean(name='IsReverseSync'),
reverseSyncInternalSecond?: int32(name='ReverseSyncInternalSecond'),
securityToken?: string(name='SecurityToken'),
}
model SwitchCSGClientsReverseSyncConfigurationResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model SwitchCSGClientsReverseSyncConfigurationResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: SwitchCSGClientsReverseSyncConfigurationResponseBody(name='body'),
}
async function switchCSGClientsReverseSyncConfigurationWithOptions(tmpReq: SwitchCSGClientsReverseSyncConfigurationRequest, runtime: Util.RuntimeOptions): SwitchCSGClientsReverseSyncConfigurationResponse {
Util.validateModel(tmpReq);
var request = new SwitchCSGClientsReverseSyncConfigurationShrinkRequest{};
OpenApiUtil.convert(tmpReq, request);
if (!Util.isUnset(tmpReq.clientIds)) {
request.clientIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.clientIds, 'ClientIds', 'simple');
}
var query = {};
if (!Util.isUnset(request.clientIdsShrink)) {
query['ClientIds'] = request.clientIdsShrink;
}
if (!Util.isUnset(request.clientRegionId)) {
query['ClientRegionId'] = request.clientRegionId;
}
if (!Util.isUnset(request.isReverseSync)) {
query['IsReverseSync'] = request.isReverseSync;
}
if (!Util.isUnset(request.reverseSyncInternalSecond)) {
query['ReverseSyncInternalSecond'] = request.reverseSyncInternalSecond;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'SwitchCSGClientsReverseSyncConfiguration',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function switchCSGClientsReverseSyncConfiguration(request: SwitchCSGClientsReverseSyncConfigurationRequest): SwitchCSGClientsReverseSyncConfigurationResponse {
var runtime = new Util.RuntimeOptions{};
return switchCSGClientsReverseSyncConfigurationWithOptions(request, runtime);
}
model SwitchGatewayExpirationPolicyRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
securityToken?: string(name='SecurityToken'),
}
model SwitchGatewayExpirationPolicyResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='395B1136-982E-4F95-BDCE-7323FFEF499E'),
success?: boolean(name='Success', example='true'),
}
model SwitchGatewayExpirationPolicyResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: SwitchGatewayExpirationPolicyResponseBody(name='body'),
}
async function switchGatewayExpirationPolicyWithOptions(request: SwitchGatewayExpirationPolicyRequest, runtime: Util.RuntimeOptions): SwitchGatewayExpirationPolicyResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'SwitchGatewayExpirationPolicy',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function switchGatewayExpirationPolicy(request: SwitchGatewayExpirationPolicyRequest): SwitchGatewayExpirationPolicyResponse {
var runtime = new Util.RuntimeOptions{};
return switchGatewayExpirationPolicyWithOptions(request, runtime);
}
model SwitchToSubscriptionRequest {
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
securityToken?: string(name='SecurityToken'),
}
model SwitchToSubscriptionResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='395B1136-982E-4F95-BDCE-7323FFEF499E'),
subscriptionURL?: string(name='SubscriptionURL', example='https://common-buy.aliyun.com/?commodityCode=hcs_sgw_csg_pre&request={"gateway_id":"gw-0007va9bnidei3s8a***”,”directBuy":"false","gateway_class":"standard","cache_cloud_efficiency_size":0}®ionId=cn-hangzhou#/buy'),
success?: boolean(name='Success', example='true'),
}
model SwitchToSubscriptionResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: SwitchToSubscriptionResponseBody(name='body'),
}
async function switchToSubscriptionWithOptions(request: SwitchToSubscriptionRequest, runtime: Util.RuntimeOptions): SwitchToSubscriptionResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'SwitchToSubscription',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function switchToSubscription(request: SwitchToSubscriptionRequest): SwitchToSubscriptionResponse {
var runtime = new Util.RuntimeOptions{};
return switchToSubscriptionWithOptions(request, runtime);
}
model TagResourcesRequest {
regionId?: string(name='RegionId', example='cn-hangzhou'),
resourceId?: [ string ](name='ResourceId'),
resourceRegionId?: string(name='ResourceRegionId', example='cn-hangzhou'),
resourceType?: string(name='ResourceType', example='GATEWAY'),
securityToken?: string(name='SecurityToken'),
tag?: [
{
key?: string(name='Key', example='testkey1'),
value?: string(name='Value', example='testvalue1'),
}
](name='Tag'),
}
model TagResourcesResponseBody = {
requestId?: string(name='RequestId', example='224DB9F7-3100-4899-AB9C-C938BCCB43E7'),
}
model TagResourcesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: TagResourcesResponseBody(name='body'),
}
async function tagResourcesWithOptions(request: TagResourcesRequest, runtime: Util.RuntimeOptions): TagResourcesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceId)) {
query['ResourceId'] = request.resourceId;
}
if (!Util.isUnset(request.resourceRegionId)) {
query['ResourceRegionId'] = request.resourceRegionId;
}
if (!Util.isUnset(request.resourceType)) {
query['ResourceType'] = request.resourceType;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.tag)) {
query['Tag'] = request.tag;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'TagResources',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function tagResources(request: TagResourcesRequest): TagResourcesResponse {
var runtime = new Util.RuntimeOptions{};
return tagResourcesWithOptions(request, runtime);
}
model TriggerGatewayRemoteSyncRequest {
gatewayId?: string(name='GatewayId'),
indexId?: string(name='IndexId'),
path?: string(name='Path'),
securityToken?: string(name='SecurityToken'),
}
model TriggerGatewayRemoteSyncResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model TriggerGatewayRemoteSyncResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: TriggerGatewayRemoteSyncResponseBody(name='body'),
}
async function triggerGatewayRemoteSyncWithOptions(request: TriggerGatewayRemoteSyncRequest, runtime: Util.RuntimeOptions): TriggerGatewayRemoteSyncResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.path)) {
query['Path'] = request.path;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'TriggerGatewayRemoteSync',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function triggerGatewayRemoteSync(request: TriggerGatewayRemoteSyncRequest): TriggerGatewayRemoteSyncResponse {
var runtime = new Util.RuntimeOptions{};
return triggerGatewayRemoteSyncWithOptions(request, runtime);
}
model UntagResourcesRequest {
all?: boolean(name='All', example='false'),
regionId?: string(name='RegionId', example='cn-hangzhou'),
resourceId?: [ string ](name='ResourceId', example='gw-uf6wjk5xxxxxxx'),
resourceRegionId?: string(name='ResourceRegionId'),
resourceType?: string(name='ResourceType', example='GATEWAY'),
securityToken?: string(name='SecurityToken'),
tagKey?: [ string ](name='TagKey', example='testkey1'),
}
model UntagResourcesResponseBody = {
requestId?: string(name='RequestId', example='601B6F25-21E7-4484-99D5-3EF2625C0088'),
}
model UntagResourcesResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: UntagResourcesResponseBody(name='body'),
}
async function untagResourcesWithOptions(request: UntagResourcesRequest, runtime: Util.RuntimeOptions): UntagResourcesResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.all)) {
query['All'] = request.all;
}
if (!Util.isUnset(request.regionId)) {
query['RegionId'] = request.regionId;
}
if (!Util.isUnset(request.resourceId)) {
query['ResourceId'] = request.resourceId;
}
if (!Util.isUnset(request.resourceRegionId)) {
query['ResourceRegionId'] = request.resourceRegionId;
}
if (!Util.isUnset(request.resourceType)) {
query['ResourceType'] = request.resourceType;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.tagKey)) {
query['TagKey'] = request.tagKey;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'UntagResources',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function untagResources(request: UntagResourcesRequest): UntagResourcesResponse {
var runtime = new Util.RuntimeOptions{};
return untagResourcesWithOptions(request, runtime);
}
model UpdateGatewayBlockVolumeRequest {
chapEnabled?: boolean(name='ChapEnabled', example='false'),
chapInPassword?: string(name='ChapInPassword', example='ChapInPassword'),
chapInUser?: string(name='ChapInUser', example='user'),
gatewayId?: string(name='GatewayId', example='gw-000eg44nmxbsfwbvq***'),
indexId?: string(name='IndexId', example='NFSalex***'),
securityToken?: string(name='SecurityToken'),
size?: long(name='Size', example='100'),
}
model UpdateGatewayBlockVolumeResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='EBAF769F-2E88-4D81-AF1E-A34FAACF9***'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000avsri6tlyddgfe***'),
}
model UpdateGatewayBlockVolumeResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: UpdateGatewayBlockVolumeResponseBody(name='body'),
}
async function updateGatewayBlockVolumeWithOptions(request: UpdateGatewayBlockVolumeRequest, runtime: Util.RuntimeOptions): UpdateGatewayBlockVolumeResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.chapEnabled)) {
query['ChapEnabled'] = request.chapEnabled;
}
if (!Util.isUnset(request.chapInPassword)) {
query['ChapInPassword'] = request.chapInPassword;
}
if (!Util.isUnset(request.chapInUser)) {
query['ChapInUser'] = request.chapInUser;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.size)) {
query['Size'] = request.size;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'UpdateGatewayBlockVolume',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function updateGatewayBlockVolume(request: UpdateGatewayBlockVolumeRequest): UpdateGatewayBlockVolumeResponse {
var runtime = new Util.RuntimeOptions{};
return updateGatewayBlockVolumeWithOptions(request, runtime);
}
model UpdateGatewayFileShareRequest {
accessBasedEnumeration?: boolean(name='AccessBasedEnumeration', example='false'),
backendLimit?: int32(name='BackendLimit', example='0'),
browsable?: boolean(name='Browsable', example='false'),
bypassCacheRead?: boolean(name='BypassCacheRead', example='false'),
cacheMode?: string(name='CacheMode', example='Cache'),
clientSideCmk?: string(name='ClientSideCmk', example='b1e08822-1e9c-4f8e-9dd1-a740cb200***'),
clientSideEncryption?: boolean(name='ClientSideEncryption', example='false'),
directIO?: boolean(name='DirectIO', example='false'),
downloadLimit?: int32(name='DownloadLimit', example='0'),
fastReclaim?: boolean(name='FastReclaim', example='true'),
frontendLimit?: int32(name='FrontendLimit', example='0'),
gatewayId?: string(name='GatewayId', example='gw-000c6hshwukkbryp****'),
ignoreDelete?: boolean(name='IgnoreDelete', example='true'),
inPlace?: boolean(name='InPlace', example='false'),
indexId?: string(name='IndexId', example='NFStest'),
kmsRotatePeriod?: long(name='KmsRotatePeriod', example='0'),
lagPeriod?: long(name='LagPeriod', example='5'),
name?: string(name='Name', example='name'),
nfsV4Optimization?: boolean(name='NfsV4Optimization', example='true'),
pollingInterval?: int32(name='PollingInterval', example='36000'),
readOnlyClientList?: string(name='ReadOnlyClientList', example='172.16.146.100'),
readOnlyUserList?: string(name='ReadOnlyUserList', example='user1,user2'),
readWriteClientList?: string(name='ReadWriteClientList', example='172.16.146.100'),
readWriteUserList?: string(name='ReadWriteUserList', example='user1,user2'),
remoteSync?: boolean(name='RemoteSync', example='true'),
remoteSyncDownload?: boolean(name='RemoteSyncDownload', example='false'),
securityToken?: string(name='SecurityToken'),
serverSideCmk?: string(name='ServerSideCmk', example='b1e08822-1e9c-4f8e-9dd1-a740cb200***'),
serverSideEncryption?: boolean(name='ServerSideEncryption', example='false'),
squash?: string(name='Squash', example='none'),
transferAcceleration?: boolean(name='TransferAcceleration', example='false'),
windowsAcl?: boolean(name='WindowsAcl', example='false'),
}
model UpdateGatewayFileShareResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='EBAF769F-2E88-4D81-AF1E-A34FAACF9***'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-000avsri6tlyddgf****'),
}
model UpdateGatewayFileShareResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: UpdateGatewayFileShareResponseBody(name='body'),
}
async function updateGatewayFileShareWithOptions(request: UpdateGatewayFileShareRequest, runtime: Util.RuntimeOptions): UpdateGatewayFileShareResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.accessBasedEnumeration)) {
query['AccessBasedEnumeration'] = request.accessBasedEnumeration;
}
if (!Util.isUnset(request.backendLimit)) {
query['BackendLimit'] = request.backendLimit;
}
if (!Util.isUnset(request.browsable)) {
query['Browsable'] = request.browsable;
}
if (!Util.isUnset(request.bypassCacheRead)) {
query['BypassCacheRead'] = request.bypassCacheRead;
}
if (!Util.isUnset(request.cacheMode)) {
query['CacheMode'] = request.cacheMode;
}
if (!Util.isUnset(request.clientSideCmk)) {
query['ClientSideCmk'] = request.clientSideCmk;
}
if (!Util.isUnset(request.clientSideEncryption)) {
query['ClientSideEncryption'] = request.clientSideEncryption;
}
if (!Util.isUnset(request.directIO)) {
query['DirectIO'] = request.directIO;
}
if (!Util.isUnset(request.downloadLimit)) {
query['DownloadLimit'] = request.downloadLimit;
}
if (!Util.isUnset(request.fastReclaim)) {
query['FastReclaim'] = request.fastReclaim;
}
if (!Util.isUnset(request.frontendLimit)) {
query['FrontendLimit'] = request.frontendLimit;
}
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.ignoreDelete)) {
query['IgnoreDelete'] = request.ignoreDelete;
}
if (!Util.isUnset(request.inPlace)) {
query['InPlace'] = request.inPlace;
}
if (!Util.isUnset(request.indexId)) {
query['IndexId'] = request.indexId;
}
if (!Util.isUnset(request.kmsRotatePeriod)) {
query['KmsRotatePeriod'] = request.kmsRotatePeriod;
}
if (!Util.isUnset(request.lagPeriod)) {
query['LagPeriod'] = request.lagPeriod;
}
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.nfsV4Optimization)) {
query['NfsV4Optimization'] = request.nfsV4Optimization;
}
if (!Util.isUnset(request.pollingInterval)) {
query['PollingInterval'] = request.pollingInterval;
}
if (!Util.isUnset(request.readOnlyClientList)) {
query['ReadOnlyClientList'] = request.readOnlyClientList;
}
if (!Util.isUnset(request.readOnlyUserList)) {
query['ReadOnlyUserList'] = request.readOnlyUserList;
}
if (!Util.isUnset(request.readWriteClientList)) {
query['ReadWriteClientList'] = request.readWriteClientList;
}
if (!Util.isUnset(request.readWriteUserList)) {
query['ReadWriteUserList'] = request.readWriteUserList;
}
if (!Util.isUnset(request.remoteSync)) {
query['RemoteSync'] = request.remoteSync;
}
if (!Util.isUnset(request.remoteSyncDownload)) {
query['RemoteSyncDownload'] = request.remoteSyncDownload;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
if (!Util.isUnset(request.serverSideCmk)) {
query['ServerSideCmk'] = request.serverSideCmk;
}
if (!Util.isUnset(request.serverSideEncryption)) {
query['ServerSideEncryption'] = request.serverSideEncryption;
}
if (!Util.isUnset(request.squash)) {
query['Squash'] = request.squash;
}
if (!Util.isUnset(request.transferAcceleration)) {
query['TransferAcceleration'] = request.transferAcceleration;
}
if (!Util.isUnset(request.windowsAcl)) {
query['WindowsAcl'] = request.windowsAcl;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'UpdateGatewayFileShare',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function updateGatewayFileShare(request: UpdateGatewayFileShareRequest): UpdateGatewayFileShareResponse {
var runtime = new Util.RuntimeOptions{};
return updateGatewayFileShareWithOptions(request, runtime);
}
model UpgradeGatewayRequest {
gatewayId?: string(name='GatewayId', example='gw-0001xv7je3580031y***'),
securityToken?: string(name='SecurityToken'),
}
model UpgradeGatewayResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='CB300009-3850-4107-B291-59BDB4EDA183'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0001xv7je3580412***'),
}
model UpgradeGatewayResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: UpgradeGatewayResponseBody(name='body'),
}
async function upgradeGatewayWithOptions(request: UpgradeGatewayRequest, runtime: Util.RuntimeOptions): UpgradeGatewayResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'UpgradeGateway',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function upgradeGateway(request: UpgradeGatewayRequest): UpgradeGatewayResponse {
var runtime = new Util.RuntimeOptions{};
return upgradeGatewayWithOptions(request, runtime);
}
model UploadCSGClientLogRequest {
clientId?: string(name='ClientId'),
clientRegionId?: string(name='ClientRegionId'),
securityToken?: string(name='SecurityToken'),
}
model UploadCSGClientLogResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
taskId?: string(name='TaskId'),
}
model UploadCSGClientLogResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: UploadCSGClientLogResponseBody(name='body'),
}
async function uploadCSGClientLogWithOptions(request: UploadCSGClientLogRequest, runtime: Util.RuntimeOptions): UploadCSGClientLogResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.clientId)) {
query['ClientId'] = request.clientId;
}
if (!Util.isUnset(request.clientRegionId)) {
query['ClientRegionId'] = request.clientRegionId;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'UploadCSGClientLog',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function uploadCSGClientLog(request: UploadCSGClientLogRequest): UploadCSGClientLogResponse {
var runtime = new Util.RuntimeOptions{};
return uploadCSGClientLogWithOptions(request, runtime);
}
model UploadGatewayLogRequest {
gatewayId?: string(name='GatewayId', example='gw-0001xv7je3031yzun***'),
}
model UploadGatewayLogResponseBody = {
code?: string(name='Code', example='200'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='CB300009-3850-4107-B291-59BDB4EDA183'),
success?: boolean(name='Success', example='true'),
taskId?: string(name='TaskId', example='t-0001xv7je3580412f***'),
}
model UploadGatewayLogResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: UploadGatewayLogResponseBody(name='body'),
}
async function uploadGatewayLogWithOptions(request: UploadGatewayLogRequest, runtime: Util.RuntimeOptions): UploadGatewayLogResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.gatewayId)) {
query['GatewayId'] = request.gatewayId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'UploadGatewayLog',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function uploadGatewayLog(request: UploadGatewayLogRequest): UploadGatewayLogResponse {
var runtime = new Util.RuntimeOptions{};
return uploadGatewayLogWithOptions(request, runtime);
}
model ValidateExpressSyncConfigRequest {
bucketName?: string(name='BucketName', example='alex***'),
bucketPrefix?: string(name='BucketPrefix', example='test***'),
bucketRegion?: string(name='BucketRegion', example='cn-hangzhou'),
name?: string(name='Name', example='sync***'),
securityToken?: string(name='SecurityToken'),
}
model ValidateExpressSyncConfigResponseBody = {
code?: string(name='Code', example='200'),
isValid?: boolean(name='IsValid', example='false'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='943856D2-814B-487A-B645-D5F9CCA15929'),
success?: boolean(name='Success', example='true'),
validateMessage?: string(name='ValidateMessage', example='ConflictExpressSyncConfig'),
}
model ValidateExpressSyncConfigResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ValidateExpressSyncConfigResponseBody(name='body'),
}
async function validateExpressSyncConfigWithOptions(request: ValidateExpressSyncConfigRequest, runtime: Util.RuntimeOptions): ValidateExpressSyncConfigResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.bucketName)) {
query['BucketName'] = request.bucketName;
}
if (!Util.isUnset(request.bucketPrefix)) {
query['BucketPrefix'] = request.bucketPrefix;
}
if (!Util.isUnset(request.bucketRegion)) {
query['BucketRegion'] = request.bucketRegion;
}
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.securityToken)) {
query['SecurityToken'] = request.securityToken;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ValidateExpressSyncConfig',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function validateExpressSyncConfig(request: ValidateExpressSyncConfigRequest): ValidateExpressSyncConfigResponse {
var runtime = new Util.RuntimeOptions{};
return validateExpressSyncConfigWithOptions(request, runtime);
}
model ValidateGatewayNameRequest {
name?: string(name='Name', example='alex***'),
storageBundleId?: string(name='StorageBundleId', example='sb-0001b2otnkdxrigeq***'),
}
model ValidateGatewayNameResponseBody = {
code?: string(name='Code', example='200'),
isValid?: boolean(name='IsValid', example='true'),
message?: string(name='Message', example='successful'),
requestId?: string(name='RequestId', example='CB300009-3850-4107-B291-59BDB4EDA183'),
success?: boolean(name='Success', example='true'),
}
model ValidateGatewayNameResponse = {
headers?: map[string]string(name='headers'),
statusCode?: int32(name='statusCode'),
body?: ValidateGatewayNameResponseBody(name='body'),
}
async function validateGatewayNameWithOptions(request: ValidateGatewayNameRequest, runtime: Util.RuntimeOptions): ValidateGatewayNameResponse {
Util.validateModel(request);
var query = {};
if (!Util.isUnset(request.name)) {
query['Name'] = request.name;
}
if (!Util.isUnset(request.storageBundleId)) {
query['StorageBundleId'] = request.storageBundleId;
}
var req = new OpenApi.OpenApiRequest{
query = OpenApiUtil.query(query),
};
var params = new OpenApi.Params{
action = 'ValidateGatewayName',
version = '2018-05-11',
protocol = 'HTTPS',
pathname = '/',
method = 'POST',
authType = 'AK',
style = 'RPC',
reqBodyType = 'formData',
bodyType = 'json',
};
return callApi(params, req, runtime);
}
async function validateGatewayName(request: ValidateGatewayNameRequest): ValidateGatewayNameResponse {
var runtime = new Util.RuntimeOptions{};
return validateGatewayNameWithOptions(request, runtime);
}