uis-20180821/main.tea

/**
 *
 */
import Util;
import OpenApi;

import EndpointUtil;

extends OpenApi;

init(config: OpenApi.Config){
  super(config);
  @endpointRule = 'regional';
  
@endpointMap = {
    cn-north-2-gov-1 = 'uis.cn-hangzhou.aliyuncs.com',
    ap-northeast-1 = 'uis.aliyuncs.com',
    ap-northeast-2-pop = 'uis.aliyuncs.com',
    ap-south-1 = 'uis.aliyuncs.com',
    ap-southeast-1 = 'uis.aliyuncs.com',
    ap-southeast-2 = 'uis.aliyuncs.com',
    ap-southeast-3 = 'uis.aliyuncs.com',
    ap-southeast-5 = 'uis.aliyuncs.com',
    cn-beijing = 'uis.aliyuncs.com',
    cn-beijing-finance-1 = 'uis.aliyuncs.com',
    cn-beijing-finance-pop = 'uis.aliyuncs.com',
    cn-beijing-gov-1 = 'uis.aliyuncs.com',
    cn-beijing-nu16-b01 = 'uis.aliyuncs.com',
    cn-chengdu = 'uis.aliyuncs.com',
    cn-edge-1 = 'uis.aliyuncs.com',
    cn-fujian = 'uis.aliyuncs.com',
    cn-haidian-cm12-c01 = 'uis.aliyuncs.com',
    cn-hangzhou-bj-b01 = 'uis.aliyuncs.com',
    cn-hangzhou-finance = 'uis.aliyuncs.com',
    cn-hangzhou-internal-prod-1 = 'uis.aliyuncs.com',
    cn-hangzhou-internal-test-1 = 'uis.aliyuncs.com',
    cn-hangzhou-internal-test-2 = 'uis.aliyuncs.com',
    cn-hangzhou-internal-test-3 = 'uis.aliyuncs.com',
    cn-hangzhou-test-306 = 'uis.aliyuncs.com',
    cn-hongkong = 'uis.aliyuncs.com',
    cn-hongkong-finance-pop = 'uis.aliyuncs.com',
    cn-huhehaote = 'uis.aliyuncs.com',
    cn-qingdao = 'uis.aliyuncs.com',
    cn-qingdao-nebula = 'uis.aliyuncs.com',
    cn-shanghai = 'uis.aliyuncs.com',
    cn-shanghai-et15-b01 = 'uis.aliyuncs.com',
    cn-shanghai-et2-b01 = 'uis.aliyuncs.com',
    cn-shanghai-finance-1 = 'uis.aliyuncs.com',
    cn-shanghai-inner = 'uis.aliyuncs.com',
    cn-shanghai-internal-test-1 = 'uis.aliyuncs.com',
    cn-shenzhen = 'uis.aliyuncs.com',
    cn-shenzhen-finance-1 = 'uis.aliyuncs.com',
    cn-shenzhen-inner = 'uis.aliyuncs.com',
    cn-shenzhen-st4-d01 = 'uis.aliyuncs.com',
    cn-shenzhen-su18-b01 = 'uis.aliyuncs.com',
    cn-wuhan = 'uis.aliyuncs.com',
    cn-yushanfang = 'uis.aliyuncs.com',
    cn-zhangbei-na61-b01 = 'uis.aliyuncs.com',
    cn-zhangjiakou = 'uis.aliyuncs.com',
    cn-zhangjiakou-na62-a01 = 'uis.aliyuncs.com',
    cn-zhengzhou-nebula-1 = 'uis.aliyuncs.com',
    eu-central-1 = 'uis.aliyuncs.com',
    eu-west-1 = 'uis.aliyuncs.com',
    eu-west-1-oxs = 'uis.aliyuncs.com',
    me-east-1 = 'uis.aliyuncs.com',
    rus-west-1-pop = 'uis.aliyuncs.com',
    us-east-1 = 'uis.aliyuncs.com',
    us-west-1 = 'uis.aliyuncs.com',
  };

  checkConfig(config);
  @endpoint = getEndpoint('uis', @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 AddHighPriorityIpRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  clientToken?: string(name='ClientToken'),
  regionId?: string(name='RegionId'),
  uisId?: string(name='UisId'),
  highPriorityIp?: string(name='HighPriorityIp'),
}

model AddHighPriorityIpResponseBody = {
  requestId?: string(name='RequestId'),
}

model AddHighPriorityIpResponse = {
  headers: map[string]string(name='headers'),
  body: AddHighPriorityIpResponseBody(name='body'),
}

async function addHighPriorityIpWithOptions(request: AddHighPriorityIpRequest, runtime: Util.RuntimeOptions): AddHighPriorityIpResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('AddHighPriorityIp', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function addHighPriorityIp(request: AddHighPriorityIpRequest): AddHighPriorityIpResponse {
  var runtime = new Util.RuntimeOptions{};
  return addHighPriorityIpWithOptions(request, runtime);
}

model AddUisNodeIpRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  clientToken?: string(name='ClientToken'),
  regionId?: string(name='RegionId'),
  uisNodeId?: string(name='UisNodeId'),
  ipAddrsNum?: int32(name='IpAddrsNum'),
}

model AddUisNodeIpResponseBody = {
  requestId?: string(name='RequestId'),
}

model AddUisNodeIpResponse = {
  headers: map[string]string(name='headers'),
  body: AddUisNodeIpResponseBody(name='body'),
}

async function addUisNodeIpWithOptions(request: AddUisNodeIpRequest, runtime: Util.RuntimeOptions): AddUisNodeIpResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('AddUisNodeIp', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function addUisNodeIp(request: AddUisNodeIpRequest): AddUisNodeIpResponse {
  var runtime = new Util.RuntimeOptions{};
  return addUisNodeIpWithOptions(request, runtime);
}

model CreateDnatEntryRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisNodeId?: string(name='UisNodeId'),
  destinationIp?: string(name='DestinationIp'),
  destinationPort?: int32(name='DestinationPort'),
  originalIp?: string(name='OriginalIp'),
  originalPort?: int32(name='OriginalPort'),
  ipProtocol?: string(name='IpProtocol'),
  name?: string(name='Name'),
}

model CreateDnatEntryResponseBody = {
  uisDnatId?: string(name='UisDnatId'),
  requestId?: string(name='RequestId'),
}

model CreateDnatEntryResponse = {
  headers: map[string]string(name='headers'),
  body: CreateDnatEntryResponseBody(name='body'),
}

async function createDnatEntryWithOptions(request: CreateDnatEntryRequest, runtime: Util.RuntimeOptions): CreateDnatEntryResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateDnatEntry', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createDnatEntry(request: CreateDnatEntryRequest): CreateDnatEntryResponse {
  var runtime = new Util.RuntimeOptions{};
  return createDnatEntryWithOptions(request, runtime);
}

model CreateSubConnectionRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisNodeId?: string(name='UisNodeId'),
  ip?: string(name='Ip'),
  description?: string(name='Description'),
  name?: string(name='Name'),
  greConfig?: string(name='GreConfig'),
}

model CreateSubConnectionResponseBody = {
  requestId?: string(name='RequestId'),
  uisSubConnectionId?: string(name='UisSubConnectionId'),
}

model CreateSubConnectionResponse = {
  headers: map[string]string(name='headers'),
  body: CreateSubConnectionResponseBody(name='body'),
}

async function createSubConnectionWithOptions(request: CreateSubConnectionRequest, runtime: Util.RuntimeOptions): CreateSubConnectionResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateSubConnection', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createSubConnection(request: CreateSubConnectionRequest): CreateSubConnectionResponse {
  var runtime = new Util.RuntimeOptions{};
  return createSubConnectionWithOptions(request, runtime);
}

model CreateUisRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  clientToken?: string(name='ClientToken'),
  name?: string(name='Name'),
  description?: string(name='Description'),
  instanceChargeType?: string(name='InstanceChargeType'),
  internetChargeType?: string(name='InternetChargeType'),
  autoPay?: boolean(name='AutoPay'),
  duration?: int32(name='Duration'),
  pricingCycle?: string(name='PricingCycle'),
  bandwidth?: int32(name='Bandwidth'),
  bandwidthType?: string(name='BandwidthType'),
  uisProtocol?: string(name='UisProtocol'),
  connectionBandwidth?: int32(name='ConnectionBandwidth'),
  connectionCount?: int32(name='ConnectionCount'),
  serviceRegion?: string(name='ServiceRegion'),
  accessType?: string(name='AccessType'),
}

model CreateUisResponseBody = {
  requestId?: string(name='RequestId'),
  uisId?: string(name='UisId'),
  orderId?: string(name='OrderId'),
}

model CreateUisResponse = {
  headers: map[string]string(name='headers'),
  body: CreateUisResponseBody(name='body'),
}

async function createUisWithOptions(request: CreateUisRequest, runtime: Util.RuntimeOptions): CreateUisResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateUis', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createUis(request: CreateUisRequest): CreateUisResponse {
  var runtime = new Util.RuntimeOptions{};
  return createUisWithOptions(request, runtime);
}

model CreateUisConnectionRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisNodeId?: string(name='UisNodeId'),
  uisProtocol?: string(name='UisProtocol'),
  description?: string(name='Description'),
  name?: string(name='Name'),
  greConfig?: string(name='GreConfig'),
  sslConfig?: string(name='SslConfig'),
}

model CreateUisConnectionResponseBody = {
  uisConnectionId?: string(name='UisConnectionId'),
  requestId?: string(name='RequestId'),
}

model CreateUisConnectionResponse = {
  headers: map[string]string(name='headers'),
  body: CreateUisConnectionResponseBody(name='body'),
}

async function createUisConnectionWithOptions(request: CreateUisConnectionRequest, runtime: Util.RuntimeOptions): CreateUisConnectionResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateUisConnection', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createUisConnection(request: CreateUisConnectionRequest): CreateUisConnectionResponse {
  var runtime = new Util.RuntimeOptions{};
  return createUisConnectionWithOptions(request, runtime);
}

model CreateUisNetworkInterfaceRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisNodeId?: string(name='UisNodeId'),
  vswitchId?: string(name='VswitchId'),
  securityGroupId?: string(name='SecurityGroupId'),
  ipAddress?: string(name='IpAddress'),
  name?: string(name='Name'),
  description?: string(name='Description'),
}

model CreateUisNetworkInterfaceResponseBody = {
  uisEniId?: string(name='UisEniId'),
  requestId?: string(name='RequestId'),
}

model CreateUisNetworkInterfaceResponse = {
  headers: map[string]string(name='headers'),
  body: CreateUisNetworkInterfaceResponseBody(name='body'),
}

async function createUisNetworkInterfaceWithOptions(request: CreateUisNetworkInterfaceRequest, runtime: Util.RuntimeOptions): CreateUisNetworkInterfaceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateUisNetworkInterface', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createUisNetworkInterface(request: CreateUisNetworkInterfaceRequest): CreateUisNetworkInterfaceResponse {
  var runtime = new Util.RuntimeOptions{};
  return createUisNetworkInterfaceWithOptions(request, runtime);
}

model CreateUisNodeRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisId?: string(name='UisId'),
  name?: string(name='Name'),
  description?: string(name='Description'),
  uisNodeBandwidth?: int32(name='UisNodeBandwidth'),
  ipAddrsNum?: int32(name='IpAddrsNum'),
  uisNodeAreaId?: string(name='UisNodeAreaId'),
}

model CreateUisNodeResponseBody = {
  requestId?: string(name='RequestId'),
  uisNodeId?: string(name='UisNodeId'),
}

model CreateUisNodeResponse = {
  headers: map[string]string(name='headers'),
  body: CreateUisNodeResponseBody(name='body'),
}

async function createUisNodeWithOptions(request: CreateUisNodeRequest, runtime: Util.RuntimeOptions): CreateUisNodeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateUisNode', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createUisNode(request: CreateUisNodeRequest): CreateUisNodeResponse {
  var runtime = new Util.RuntimeOptions{};
  return createUisNodeWithOptions(request, runtime);
}

model DeleteDnatEntryRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisNodeId?: string(name='UisNodeId'),
  uisDnatId?: string(name='UisDnatId'),
}

model DeleteDnatEntryResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteDnatEntryResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteDnatEntryResponseBody(name='body'),
}

async function deleteDnatEntryWithOptions(request: DeleteDnatEntryRequest, runtime: Util.RuntimeOptions): DeleteDnatEntryResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteDnatEntry', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteDnatEntry(request: DeleteDnatEntryRequest): DeleteDnatEntryResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteDnatEntryWithOptions(request, runtime);
}

model DeleteHighPriorityIpRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  clientToken?: string(name='ClientToken'),
  regionId?: string(name='RegionId'),
  uisId?: string(name='UisId'),
  highPriorityIp?: string(name='HighPriorityIp'),
}

model DeleteHighPriorityIpResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteHighPriorityIpResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteHighPriorityIpResponseBody(name='body'),
}

async function deleteHighPriorityIpWithOptions(request: DeleteHighPriorityIpRequest, runtime: Util.RuntimeOptions): DeleteHighPriorityIpResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteHighPriorityIp', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteHighPriorityIp(request: DeleteHighPriorityIpRequest): DeleteHighPriorityIpResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteHighPriorityIpWithOptions(request, runtime);
}

model DeleteSubConnectionRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisSubConnectionId?: string(name='UisSubConnectionId'),
}

model DeleteSubConnectionResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteSubConnectionResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteSubConnectionResponseBody(name='body'),
}

async function deleteSubConnectionWithOptions(request: DeleteSubConnectionRequest, runtime: Util.RuntimeOptions): DeleteSubConnectionResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteSubConnection', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteSubConnection(request: DeleteSubConnectionRequest): DeleteSubConnectionResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteSubConnectionWithOptions(request, runtime);
}

model DeleteUisRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  clientToken?: string(name='ClientToken'),
  regionId?: string(name='RegionId'),
  uisId?: string(name='UisId'),
}

model DeleteUisResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteUisResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteUisResponseBody(name='body'),
}

async function deleteUisWithOptions(request: DeleteUisRequest, runtime: Util.RuntimeOptions): DeleteUisResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteUis', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteUis(request: DeleteUisRequest): DeleteUisResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteUisWithOptions(request, runtime);
}

model DeleteUisConnectionRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  clientToken?: string(name='ClientToken'),
  uisConnectionId?: string(name='UisConnectionId'),
  uisNodeId?: string(name='UisNodeId'),
}

model DeleteUisConnectionResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteUisConnectionResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteUisConnectionResponseBody(name='body'),
}

async function deleteUisConnectionWithOptions(request: DeleteUisConnectionRequest, runtime: Util.RuntimeOptions): DeleteUisConnectionResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteUisConnection', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteUisConnection(request: DeleteUisConnectionRequest): DeleteUisConnectionResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteUisConnectionWithOptions(request, runtime);
}

model DeleteUisNetworkInterfaceRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisNodeId?: string(name='UisNodeId'),
  uisEniId?: string(name='UisEniId'),
}

model DeleteUisNetworkInterfaceResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteUisNetworkInterfaceResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteUisNetworkInterfaceResponseBody(name='body'),
}

async function deleteUisNetworkInterfaceWithOptions(request: DeleteUisNetworkInterfaceRequest, runtime: Util.RuntimeOptions): DeleteUisNetworkInterfaceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteUisNetworkInterface', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteUisNetworkInterface(request: DeleteUisNetworkInterfaceRequest): DeleteUisNetworkInterfaceResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteUisNetworkInterfaceWithOptions(request, runtime);
}

model DeleteUisNodeRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  clientToken?: string(name='ClientToken'),
  uisId?: string(name='UisId'),
  uisNodeId?: string(name='UisNodeId'),
}

model DeleteUisNodeResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteUisNodeResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteUisNodeResponseBody(name='body'),
}

async function deleteUisNodeWithOptions(request: DeleteUisNodeRequest, runtime: Util.RuntimeOptions): DeleteUisNodeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteUisNode', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteUisNode(request: DeleteUisNodeRequest): DeleteUisNodeResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteUisNodeWithOptions(request, runtime);
}

model DeleteUisNodeIpRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  clientToken?: string(name='ClientToken'),
  regionId?: string(name='RegionId'),
  uisNodeId?: string(name='UisNodeId'),
  uisNodeIpAddress?: string(name='UisNodeIpAddress'),
}

model DeleteUisNodeIpResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteUisNodeIpResponse = {
  headers: map[string]string(name='headers'),
  body: DeleteUisNodeIpResponseBody(name='body'),
}

async function deleteUisNodeIpWithOptions(request: DeleteUisNodeIpRequest, runtime: Util.RuntimeOptions): DeleteUisNodeIpResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteUisNodeIp', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteUisNodeIp(request: DeleteUisNodeIpRequest): DeleteUisNodeIpResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteUisNodeIpWithOptions(request, runtime);
}

model DescribeAreasRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
}

model DescribeAreasResponseBody = {
  requestId?: string(name='RequestId'),
  areas?: {
    area?: [ 
    {
      localName?: string(name='LocalName'),
      areaId?: string(name='AreaId'),
    }
  ](name='Area')
  }(name='Areas'),
}

model DescribeAreasResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeAreasResponseBody(name='body'),
}

async function describeAreasWithOptions(request: DescribeAreasRequest, runtime: Util.RuntimeOptions): DescribeAreasResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeAreas', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeAreas(request: DescribeAreasRequest): DescribeAreasResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAreasWithOptions(request, runtime);
}

model DescribeDnatEntriesRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisNodeId?: string(name='UisNodeId'),
  uisDnatId?: string(name='UisDnatId'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeDnatEntriesResponseBody = {
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  pageNumber?: int32(name='PageNumber'),
  uisDnatEntries?: {
    uisDnatEntry?: [ 
    {
      originalPort?: int32(name='OriginalPort'),
      destinationPort?: int32(name='DestinationPort'),
      originalIp?: string(name='OriginalIp'),
      ipProtocol?: string(name='IpProtocol'),
      uisDnatId?: string(name='UisDnatId'),
      destinationIp?: string(name='DestinationIp'),
    }
  ](name='UisDnatEntry')
  }(name='UisDnatEntries'),
}

model DescribeDnatEntriesResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeDnatEntriesResponseBody(name='body'),
}

async function describeDnatEntriesWithOptions(request: DescribeDnatEntriesRequest, runtime: Util.RuntimeOptions): DescribeDnatEntriesResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeDnatEntries', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeDnatEntries(request: DescribeDnatEntriesRequest): DescribeDnatEntriesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeDnatEntriesWithOptions(request, runtime);
}

model DescribeHighPriorityIpRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisId?: string(name='UisId'),
  highPriorityIp?: string(name='HighPriorityIp'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  clientToken?: string(name='ClientToken'),
}

model DescribeHighPriorityIpResponseBody = {
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  pageNumber?: int32(name='PageNumber'),
  highPriorityIps?: {
    highPriorityIp?: [ 
    {
      staticOffAreaId?: string(name='StaticOffAreaId'),
      domain?: string(name='Domain'),
      dynamicOffAreaId?: string(name='DynamicOffAreaId'),
      state?: string(name='State'),
      ip?: string(name='Ip'),
      boardAreaId?: string(name='BoardAreaId'),
    }
  ](name='HighPriorityIp')
  }(name='HighPriorityIps'),
}

model DescribeHighPriorityIpResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeHighPriorityIpResponseBody(name='body'),
}

async function describeHighPriorityIpWithOptions(request: DescribeHighPriorityIpRequest, runtime: Util.RuntimeOptions): DescribeHighPriorityIpResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeHighPriorityIp', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeHighPriorityIp(request: DescribeHighPriorityIpRequest): DescribeHighPriorityIpResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeHighPriorityIpWithOptions(request, runtime);
}

model DescribeHighPriorityIpsRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisId?: string(name='UisId'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeHighPriorityIpsResponseBody = {
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  pageNumber?: int32(name='PageNumber'),
  highPriorityIps?: {
    highPriorityIp?: [ 
    {
      areaId?: string(name='AreaId'),
      destination?: string(name='Destination'),
    }
  ](name='HighPriorityIp')
  }(name='HighPriorityIps'),
}

model DescribeHighPriorityIpsResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeHighPriorityIpsResponseBody(name='body'),
}

async function describeHighPriorityIpsWithOptions(request: DescribeHighPriorityIpsRequest, runtime: Util.RuntimeOptions): DescribeHighPriorityIpsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeHighPriorityIps', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeHighPriorityIps(request: DescribeHighPriorityIpsRequest): DescribeHighPriorityIpsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeHighPriorityIpsWithOptions(request, runtime);
}

model DescribeRegionsRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model DescribeRegionsResponseBody = {
  requestId?: string(name='RequestId'),
  regions?: {
    region?: [ 
    {
      localName?: string(name='LocalName'),
      regionId?: string(name='RegionId'),
    }
  ](name='Region')
  }(name='Regions'),
}

model DescribeRegionsResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeRegionsResponseBody(name='body'),
}

async function describeRegionsWithOptions(request: DescribeRegionsRequest, runtime: Util.RuntimeOptions): DescribeRegionsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeRegions', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeRegions(request: DescribeRegionsRequest): DescribeRegionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRegionsWithOptions(request, runtime);
}

model DescribeSubConnectionRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisSubConnectionId?: string(name='UisSubConnectionId'),
}

model DescribeSubConnectionResponseBody = {
  customerTunnelIp?: string(name='CustomerTunnelIp'),
  description?: string(name='Description'),
  localTunnelIp?: string(name='LocalTunnelIp'),
  requestId?: string(name='RequestId'),
  uisId?: string(name='UisId'),
  customerIp?: string(name='CustomerIp'),
  ip?: string(name='Ip'),
  uisNodeId?: string(name='UisNodeId'),
  uisSubConnectionId?: string(name='UisSubConnectionId'),
  customerSubnet?: string(name='CustomerSubnet'),
  name?: string(name='Name'),
}

model DescribeSubConnectionResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeSubConnectionResponseBody(name='body'),
}

async function describeSubConnectionWithOptions(request: DescribeSubConnectionRequest, runtime: Util.RuntimeOptions): DescribeSubConnectionResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeSubConnection', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeSubConnection(request: DescribeSubConnectionRequest): DescribeSubConnectionResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSubConnectionWithOptions(request, runtime);
}

model DescribeSubConnectionsRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisNodeId?: string(name='UisNodeId'),
  IP?: string(name='IP'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeSubConnectionsResponseBody = {
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  pageNumber?: int32(name='PageNumber'),
  uisSubConnections?: {
    uisSubConnection?: [ 
    {
      uisSubConnectionId?: string(name='UisSubConnectionId'),
      description?: string(name='Description'),
      createTime?: long(name='CreateTime'),
      ip?: string(name='Ip'),
      name?: string(name='Name'),
    }
  ](name='UisSubConnection')
  }(name='UisSubConnections'),
}

model DescribeSubConnectionsResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeSubConnectionsResponseBody(name='body'),
}

async function describeSubConnectionsWithOptions(request: DescribeSubConnectionsRequest, runtime: Util.RuntimeOptions): DescribeSubConnectionsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeSubConnections', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeSubConnections(request: DescribeSubConnectionsRequest): DescribeSubConnectionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSubConnectionsWithOptions(request, runtime);
}

model DescribeUisConnectionsRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisNodeId?: string(name='UisNodeId'),
  uisConnectionId?: string(name='UisConnectionId'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  clientToken?: string(name='ClientToken'),
}

model DescribeUisConnectionsResponseBody = {
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  pageNumber?: int32(name='PageNumber'),
  uisConnections?: {
    uisConnection?: [ 
    {
      greConfig?: string(name='GreConfig'),
      uisId?: string(name='UisId'),
      uisNodeId?: string(name='UisNodeId'),
      description?: string(name='Description'),
      state?: string(name='State'),
      uisProtocol?: string(name='UisProtocol'),
      name?: string(name='Name'),
      sslConfig?: string(name='SslConfig'),
      uisConnectionId?: string(name='UisConnectionId'),
    }
  ](name='UisConnection')
  }(name='UisConnections'),
}

model DescribeUisConnectionsResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeUisConnectionsResponseBody(name='body'),
}

async function describeUisConnectionsWithOptions(request: DescribeUisConnectionsRequest, runtime: Util.RuntimeOptions): DescribeUisConnectionsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeUisConnections', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUisConnections(request: DescribeUisConnectionsRequest): DescribeUisConnectionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUisConnectionsWithOptions(request, runtime);
}

model DescribeUiseNodeStatusRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisNodeId?: string(name='UisNodeId'),
  ip?: string(name='Ip'),
}

model DescribeUiseNodeStatusResponseBody = {
  requestId?: string(name='RequestId'),
  ipStatusList?: {
    ipStatus?: [ 
    {
      currentConnections?: int32(name='CurrentConnections'),
      ip?: string(name='Ip'),
      maxConnections?: int32(name='MaxConnections'),
    }
  ](name='IpStatus')
  }(name='IpStatusList'),
}

model DescribeUiseNodeStatusResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeUiseNodeStatusResponseBody(name='body'),
}

async function describeUiseNodeStatusWithOptions(request: DescribeUiseNodeStatusRequest, runtime: Util.RuntimeOptions): DescribeUiseNodeStatusResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeUiseNodeStatus', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUiseNodeStatus(request: DescribeUiseNodeStatusRequest): DescribeUiseNodeStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUiseNodeStatusWithOptions(request, runtime);
}

model DescribeUisesRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisId?: string(name='UisId'),
  name?: string(name='Name'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeUisesResponseBody = {
  totalCount?: int32(name='TotalCount'),
  uises?: {
    uis?: [ 
    {
      status?: string(name='Status'),
      uisId?: string(name='UisId'),
      connectionType?: string(name='ConnectionType'),
      bandwidthType?: string(name='BandwidthType'),
      createTime?: long(name='CreateTime'),
      chargeType?: string(name='ChargeType'),
      payType?: string(name='PayType'),
      userInfo?: {
        clientInfoDBAccount?: string(name='ClientInfoDBAccount'),
        clientInfoDB?: string(name='ClientInfoDB'),
        clientInfoDBPassword?: string(name='ClientInfoDBPassword'),
      }(name='UserInfo'),
      sslClientCertUrl?: string(name='SslClientCertUrl'),
      connectionCount?: int32(name='ConnectionCount'),
      uisNodeIds?: {
        uisNodeIds?: [ string ](name='UisNodeIds')
      }(name='UisNodeIds'),
      endTime?: long(name='EndTime'),
      bandwidth?: int32(name='Bandwidth'),
      description?: string(name='Description'),
      serviceRegion?: string(name='ServiceRegion'),
      connectionBandwidth?: int32(name='ConnectionBandwidth'),
      businessStatus?: string(name='BusinessStatus'),
      name?: string(name='Name'),
    }
  ](name='Uis')
  }(name='Uises'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  pageNumber?: int32(name='PageNumber'),
}

model DescribeUisesResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeUisesResponseBody(name='body'),
}

async function describeUisesWithOptions(request: DescribeUisesRequest, runtime: Util.RuntimeOptions): DescribeUisesResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeUises', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUises(request: DescribeUisesRequest): DescribeUisesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUisesWithOptions(request, runtime);
}

model DescribeUisNetworkInterfacesRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisNodeId?: string(name='UisNodeId'),
  uisEniId?: string(name='UisEniId'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeUisNetworkInterfacesResponseBody = {
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  pageNumber?: int32(name='PageNumber'),
  networkInterfaces?: {
    networkInterface?: [ 
    {
      uisEniId?: string(name='UisEniId'),
      uisNodeId?: string(name='UisNodeId'),
      ipAddress?: string(name='IpAddress'),
      description?: string(name='Description'),
      vswitchId?: string(name='VswitchId'),
      state?: string(name='State'),
      securityGroupID?: string(name='SecurityGroupID'),
      networkInterfaceId?: string(name='NetworkInterfaceId'),
      name?: string(name='Name'),
      log?: string(name='Log'),
    }
  ](name='NetworkInterface')
  }(name='NetworkInterfaces'),
}

model DescribeUisNetworkInterfacesResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeUisNetworkInterfacesResponseBody(name='body'),
}

async function describeUisNetworkInterfacesWithOptions(request: DescribeUisNetworkInterfacesRequest, runtime: Util.RuntimeOptions): DescribeUisNetworkInterfacesResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeUisNetworkInterfaces', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUisNetworkInterfaces(request: DescribeUisNetworkInterfacesRequest): DescribeUisNetworkInterfacesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUisNetworkInterfacesWithOptions(request, runtime);
}

model DescribeUisNodesRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisId?: string(name='UisId'),
  uisNodeId?: string(name='UisNodeId'),
  name?: string(name='Name'),
  status?: string(name='Status'),
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
  clientToken?: string(name='ClientToken'),
}

model DescribeUisNodesResponseBody = {
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  pageNumber?: int32(name='PageNumber'),
  uisNodeList?: {
    uisNode?: [ 
    {
      status?: string(name='Status'),
      uisId?: string(name='UisId'),
      uisNodeActiveIp?: string(name='UisNodeActiveIp'),
      createTime?: long(name='CreateTime'),
      uisEniIps?: string(name='UisEniIps'),
      uisNodeAreaId?: string(name='UisNodeAreaId'),
      uisNodeId?: string(name='UisNodeId'),
      uisNodeIps?: string(name='UisNodeIps'),
      description?: string(name='Description'),
      uisNodeBandwidth?: int32(name='UisNodeBandwidth'),
      ipAddrsNum?: int32(name='IpAddrsNum'),
      name?: string(name='Name'),
    }
  ](name='UisNode')
  }(name='UisNodeList'),
}

model DescribeUisNodesResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeUisNodesResponseBody(name='body'),
}

async function describeUisNodesWithOptions(request: DescribeUisNodesRequest, runtime: Util.RuntimeOptions): DescribeUisNodesResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeUisNodes', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUisNodes(request: DescribeUisNodesRequest): DescribeUisNodesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUisNodesWithOptions(request, runtime);
}

model DescribeWhiteListRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisId?: string(name='UisId'),
  clientToken?: string(name='ClientToken'),
}

model DescribeWhiteListResponseBody = {
  requestId?: string(name='RequestId'),
  whitelist?: string(name='Whitelist'),
}

model DescribeWhiteListResponse = {
  headers: map[string]string(name='headers'),
  body: DescribeWhiteListResponseBody(name='body'),
}

async function describeWhiteListWithOptions(request: DescribeWhiteListRequest, runtime: Util.RuntimeOptions): DescribeWhiteListResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeWhiteList', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeWhiteList(request: DescribeWhiteListRequest): DescribeWhiteListResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWhiteListWithOptions(request, runtime);
}

model GetDroppedIpListRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisId?: string(name='UisId'),
  chartDate?: string(name='ChartDate'),
}

model GetDroppedIpListResponseBody = {
  requestId?: string(name='RequestId'),
  droppedIpListUrl?: string(name='DroppedIpListUrl'),
}

model GetDroppedIpListResponse = {
  headers: map[string]string(name='headers'),
  body: GetDroppedIpListResponseBody(name='body'),
}

async function getDroppedIpListWithOptions(request: GetDroppedIpListRequest, runtime: Util.RuntimeOptions): GetDroppedIpListResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetDroppedIpList', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getDroppedIpList(request: GetDroppedIpListRequest): GetDroppedIpListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDroppedIpListWithOptions(request, runtime);
}

model ModifyDnatEntryRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisNodeId?: string(name='UisNodeId'),
  uisDnatId?: string(name='UisDnatId'),
  destinationIp?: string(name='DestinationIp'),
  destinationPort?: int32(name='DestinationPort'),
  originalIp?: string(name='OriginalIp'),
  originalPort?: int32(name='OriginalPort'),
  ipProtocol?: string(name='IpProtocol'),
  name?: string(name='Name'),
}

model ModifyDnatEntryResponseBody = {
  requestId?: string(name='RequestId'),
}

model ModifyDnatEntryResponse = {
  headers: map[string]string(name='headers'),
  body: ModifyDnatEntryResponseBody(name='body'),
}

async function modifyDnatEntryWithOptions(request: ModifyDnatEntryRequest, runtime: Util.RuntimeOptions): ModifyDnatEntryResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ModifyDnatEntry', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function modifyDnatEntry(request: ModifyDnatEntryRequest): ModifyDnatEntryResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyDnatEntryWithOptions(request, runtime);
}

model ModifyHighPriorityIpRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  clientToken?: string(name='ClientToken'),
  uisId?: string(name='UisId'),
  highPriorityIp?: string(name='HighPriorityIp'),
}

model ModifyHighPriorityIpResponseBody = {
  requestId?: string(name='RequestId'),
}

model ModifyHighPriorityIpResponse = {
  headers: map[string]string(name='headers'),
  body: ModifyHighPriorityIpResponseBody(name='body'),
}

async function modifyHighPriorityIpWithOptions(request: ModifyHighPriorityIpRequest, runtime: Util.RuntimeOptions): ModifyHighPriorityIpResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ModifyHighPriorityIp', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function modifyHighPriorityIp(request: ModifyHighPriorityIpRequest): ModifyHighPriorityIpResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyHighPriorityIpWithOptions(request, runtime);
}

model ModifySubConnectionRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  uisSubConnectionId?: string(name='UisSubConnectionId'),
  description?: string(name='Description'),
  name?: string(name='Name'),
  greConfig?: string(name='GreConfig'),
}

model ModifySubConnectionResponseBody = {
  requestId?: string(name='RequestId'),
}

model ModifySubConnectionResponse = {
  headers: map[string]string(name='headers'),
  body: ModifySubConnectionResponseBody(name='body'),
}

async function modifySubConnectionWithOptions(request: ModifySubConnectionRequest, runtime: Util.RuntimeOptions): ModifySubConnectionResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ModifySubConnection', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function modifySubConnection(request: ModifySubConnectionRequest): ModifySubConnectionResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifySubConnectionWithOptions(request, runtime);
}

model ModifyUisAttributeRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  clientToken?: string(name='ClientToken'),
  uisId?: string(name='UisId'),
  name?: string(name='Name'),
  description?: string(name='Description'),
  regionId?: string(name='RegionId'),
}

model ModifyUisAttributeResponseBody = {
  requestId?: string(name='RequestId'),
}

model ModifyUisAttributeResponse = {
  headers: map[string]string(name='headers'),
  body: ModifyUisAttributeResponseBody(name='body'),
}

async function modifyUisAttributeWithOptions(request: ModifyUisAttributeRequest, runtime: Util.RuntimeOptions): ModifyUisAttributeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ModifyUisAttribute', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function modifyUisAttribute(request: ModifyUisAttributeRequest): ModifyUisAttributeResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyUisAttributeWithOptions(request, runtime);
}

model ModifyUisConnectionAttributeRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisNodeId?: string(name='UisNodeId'),
  uisConnectionId?: string(name='UisConnectionId'),
  uisProtocol?: string(name='UisProtocol'),
  description?: string(name='Description'),
  name?: string(name='Name'),
  greConfig?: string(name='GreConfig'),
  sslConfig?: string(name='SslConfig'),
}

model ModifyUisConnectionAttributeResponseBody = {
  requestId?: string(name='RequestId'),
}

model ModifyUisConnectionAttributeResponse = {
  headers: map[string]string(name='headers'),
  body: ModifyUisConnectionAttributeResponseBody(name='body'),
}

async function modifyUisConnectionAttributeWithOptions(request: ModifyUisConnectionAttributeRequest, runtime: Util.RuntimeOptions): ModifyUisConnectionAttributeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ModifyUisConnectionAttribute', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function modifyUisConnectionAttribute(request: ModifyUisConnectionAttributeRequest): ModifyUisConnectionAttributeResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyUisConnectionAttributeWithOptions(request, runtime);
}

model ModifyUisNodeAttributeRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  uisId?: string(name='UisId'),
  uisNodeId?: string(name='UisNodeId'),
  name?: string(name='Name'),
  description?: string(name='Description'),
  uisNodeBandwidth?: int32(name='UisNodeBandwidth'),
}

model ModifyUisNodeAttributeResponseBody = {
  requestId?: string(name='RequestId'),
}

model ModifyUisNodeAttributeResponse = {
  headers: map[string]string(name='headers'),
  body: ModifyUisNodeAttributeResponseBody(name='body'),
}

async function modifyUisNodeAttributeWithOptions(request: ModifyUisNodeAttributeRequest, runtime: Util.RuntimeOptions): ModifyUisNodeAttributeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ModifyUisNodeAttribute', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function modifyUisNodeAttribute(request: ModifyUisNodeAttributeRequest): ModifyUisNodeAttributeResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyUisNodeAttributeWithOptions(request, runtime);
}

model ModifyWhiteListRequest {
  ownerAccount?: string(name='OwnerAccount'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  regionId?: string(name='RegionId'),
  clientToken?: string(name='ClientToken'),
  uisId?: string(name='UisId'),
  whitelist?: string(name='Whitelist'),
  modifyMode?: string(name='ModifyMode'),
}

model ModifyWhiteListResponseBody = {
  requestId?: string(name='RequestId'),
}

model ModifyWhiteListResponse = {
  headers: map[string]string(name='headers'),
  body: ModifyWhiteListResponseBody(name='body'),
}

async function modifyWhiteListWithOptions(request: ModifyWhiteListRequest, runtime: Util.RuntimeOptions): ModifyWhiteListResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ModifyWhiteList', '2018-08-21', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function modifyWhiteList(request: ModifyWhiteListRequest): ModifyWhiteListResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyWhiteListWithOptions(request, runtime);
}