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

import EndpointUtil;

extends OpenApi;

init(config: OpenApi.Config){
  super(config);
  @endpointRule = 'regional';
  
  @endpointMap = {
    ap-northeast-1 = 'green.ap-southeast-1.aliyuncs.com',
    ap-south-1 = 'green.ap-southeast-1.aliyuncs.com',
    ap-southeast-2 = 'green.ap-southeast-1.aliyuncs.com',
    ap-southeast-3 = 'green.ap-southeast-1.aliyuncs.com',
    ap-southeast-5 = 'green.ap-southeast-1.aliyuncs.com',
    cn-chengdu = 'green.aliyuncs.com',
    cn-hongkong = 'green.aliyuncs.com',
    cn-huhehaote = 'green.aliyuncs.com',
    cn-qingdao = 'green.aliyuncs.com',
    cn-zhangjiakou = 'green.aliyuncs.com',
    eu-central-1 = 'green.ap-southeast-1.aliyuncs.com',
    eu-west-1 = 'green.ap-southeast-1.aliyuncs.com',
    me-east-1 = 'green.ap-southeast-1.aliyuncs.com',
    us-east-1 = 'green.ap-southeast-1.aliyuncs.com',
    cn-hangzhou-finance = 'green.aliyuncs.com',
    cn-shenzhen-finance-1 = 'green.aliyuncs.com',
    cn-shanghai-finance-1 = 'green.aliyuncs.com',
    cn-north-2-gov-1 = 'green.aliyuncs.com',
  };
  checkConfig(config);
  @endpoint = getEndpoint('green', @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 CreatCustomOcrTemplateRequest {
  name?: string(name='Name'),
  imgUrl?: string(name='ImgUrl'),
  referArea?: string(name='ReferArea'),
  recognizeArea?: string(name='RecognizeArea'),
}

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

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

async function creatCustomOcrTemplateWithOptions(request: CreatCustomOcrTemplateRequest, runtime: Util.RuntimeOptions): CreatCustomOcrTemplateResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreatCustomOcrTemplate', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function creatCustomOcrTemplate(request: CreatCustomOcrTemplateRequest): CreatCustomOcrTemplateResponse {
  var runtime = new Util.RuntimeOptions{};
  return creatCustomOcrTemplateWithOptions(request, runtime);
}

model CreateBizTypeRequest {
  bizTypeName?: string(name='BizTypeName'),
  bizTypeImport?: string(name='BizTypeImport'),
  industryInfo?: string(name='IndustryInfo'),
  citeTemplate?: boolean(name='CiteTemplate'),
  description?: string(name='Description'),
}

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

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

async function createBizTypeWithOptions(request: CreateBizTypeRequest, runtime: Util.RuntimeOptions): CreateBizTypeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateBizType', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createBizType(request: CreateBizTypeRequest): CreateBizTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return createBizTypeWithOptions(request, runtime);
}

model CreateCdiBagRequest {
  clientToken?: string(name='ClientToken'),
  ownerId?: long(name='OwnerId'),
  commodityCode?: string(name='CommodityCode'),
  orderType?: string(name='OrderType'),
  flowOutSpec?: int32(name='FlowOutSpec'),
  orderNum?: int32(name='OrderNum'),
}

model CreateCdiBagResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  orderId?: string(name='OrderId'),
  instanceIds?: {
    string?: [ string ](name='String')
  }(name='InstanceIds'),
  code?: string(name='Code'),
}

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

async function createCdiBagWithOptions(request: CreateCdiBagRequest, runtime: Util.RuntimeOptions): CreateCdiBagResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateCdiBag', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createCdiBag(request: CreateCdiBagRequest): CreateCdiBagResponse {
  var runtime = new Util.RuntimeOptions{};
  return createCdiBagWithOptions(request, runtime);
}

model CreateCdiBaseBagRequest {
  clientToken?: string(name='ClientToken'),
  ownerId?: long(name='OwnerId'),
  commodityCode?: string(name='CommodityCode'),
  orderType?: string(name='OrderType'),
  duration?: int32(name='Duration'),
  flowOutSpec?: int32(name='FlowOutSpec'),
}

model CreateCdiBaseBagResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  instanceId?: string(name='InstanceId'),
  orderId?: string(name='OrderId'),
  code?: string(name='Code'),
}

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

async function createCdiBaseBagWithOptions(request: CreateCdiBaseBagRequest, runtime: Util.RuntimeOptions): CreateCdiBaseBagResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateCdiBaseBag', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createCdiBaseBag(request: CreateCdiBaseBagRequest): CreateCdiBaseBagResponse {
  var runtime = new Util.RuntimeOptions{};
  return createCdiBaseBagWithOptions(request, runtime);
}

model CreateImageLibRequest {
  sourceIp?: string(name='SourceIp'),
  serviceModule?: string(name='ServiceModule'),
  name?: string(name='Name'),
  scene?: string(name='Scene'),
  category?: string(name='Category'),
  bizTypes?: string(name='BizTypes'),
  enable?: boolean(name='Enable'),
}

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

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

async function createImageLibWithOptions(request: CreateImageLibRequest, runtime: Util.RuntimeOptions): CreateImageLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateImageLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createImageLib(request: CreateImageLibRequest): CreateImageLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return createImageLibWithOptions(request, runtime);
}

model CreateKeywordRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  keywordLibId?: long(name='KeywordLibId'),
  keywords?: string(name='Keywords'),
}

model CreateKeywordResponseBody = {
  requestId?: string(name='RequestId'),
  invalidKeywordList?: [ string ](name='InvalidKeywordList'),
  validKeywordList?: [ 
    {
      keyword?: string(name='keyword'),
      id?: int32(name='id'),
    }
  ](name='validKeywordList'),
  successCount?: int32(name='SuccessCount'),
}

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

async function createKeywordWithOptions(request: CreateKeywordRequest, runtime: Util.RuntimeOptions): CreateKeywordResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateKeyword', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createKeyword(request: CreateKeywordRequest): CreateKeywordResponse {
  var runtime = new Util.RuntimeOptions{};
  return createKeywordWithOptions(request, runtime);
}

model CreateKeywordLibRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  serviceModule?: string(name='ServiceModule'),
  name?: string(name='Name'),
  resourceType?: string(name='ResourceType'),
  libType?: string(name='LibType'),
  category?: string(name='Category'),
  bizTypes?: string(name='BizTypes'),
  language?: string(name='Language'),
  matchMode?: string(name='MatchMode'),
  enable?: boolean(name='Enable'),
}

model CreateKeywordLibResponseBody = {
  requestId?: string(name='RequestId'),
  id?: string(name='Id'),
}

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

async function createKeywordLibWithOptions(request: CreateKeywordLibRequest, runtime: Util.RuntimeOptions): CreateKeywordLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateKeywordLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createKeywordLib(request: CreateKeywordLibRequest): CreateKeywordLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return createKeywordLibWithOptions(request, runtime);
}

model CreateWebsiteIndexPageBaselineRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  instanceId?: string(name='InstanceId'),
}

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

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

async function createWebsiteIndexPageBaselineWithOptions(request: CreateWebsiteIndexPageBaselineRequest, runtime: Util.RuntimeOptions): CreateWebsiteIndexPageBaselineResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateWebsiteIndexPageBaseline', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createWebsiteIndexPageBaseline(request: CreateWebsiteIndexPageBaselineRequest): CreateWebsiteIndexPageBaselineResponse {
  var runtime = new Util.RuntimeOptions{};
  return createWebsiteIndexPageBaselineWithOptions(request, runtime);
}

model CreateWebSiteInstanceRequest {
  clientToken?: string(name='ClientToken'),
  ownerId?: long(name='OwnerId'),
  orderType?: string(name='OrderType'),
  duration?: int32(name='Duration'),
  pricingCycle?: string(name='PricingCycle'),
  orderNum?: int32(name='OrderNum'),
}

model CreateWebSiteInstanceResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  orderId?: string(name='OrderId'),
  instanceIds?: {
    string?: [ string ](name='String')
  }(name='InstanceIds'),
  code?: string(name='Code'),
}

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

async function createWebSiteInstanceWithOptions(request: CreateWebSiteInstanceRequest, runtime: Util.RuntimeOptions): CreateWebSiteInstanceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateWebSiteInstance', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createWebSiteInstance(request: CreateWebSiteInstanceRequest): CreateWebSiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return createWebSiteInstanceWithOptions(request, runtime);
}

model DeleteBizTypeRequest {
  bizTypeName?: string(name='BizTypeName'),
}

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

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

async function deleteBizTypeWithOptions(request: DeleteBizTypeRequest, runtime: Util.RuntimeOptions): DeleteBizTypeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteBizType', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteBizType(request: DeleteBizTypeRequest): DeleteBizTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteBizTypeWithOptions(request, runtime);
}

model DeleteCustomOcrTemplateRequest {
  ids?: string(name='Ids'),
}

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

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

async function deleteCustomOcrTemplateWithOptions(request: DeleteCustomOcrTemplateRequest, runtime: Util.RuntimeOptions): DeleteCustomOcrTemplateResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteCustomOcrTemplate', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteCustomOcrTemplate(request: DeleteCustomOcrTemplateRequest): DeleteCustomOcrTemplateResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteCustomOcrTemplateWithOptions(request, runtime);
}

model DeleteImageFromLibRequest {
  sourceIp?: string(name='SourceIp'),
  ids?: string(name='Ids'),
}

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

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

async function deleteImageFromLibWithOptions(request: DeleteImageFromLibRequest, runtime: Util.RuntimeOptions): DeleteImageFromLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteImageFromLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteImageFromLib(request: DeleteImageFromLibRequest): DeleteImageFromLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteImageFromLibWithOptions(request, runtime);
}

model DeleteImageLibRequest {
  sourceIp?: string(name='SourceIp'),
  id?: int32(name='Id'),
}

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

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

async function deleteImageLibWithOptions(request: DeleteImageLibRequest, runtime: Util.RuntimeOptions): DeleteImageLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteImageLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteImageLib(request: DeleteImageLibRequest): DeleteImageLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteImageLibWithOptions(request, runtime);
}

model DeleteKeywordRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  ids?: string(name='Ids'),
  keywords?: string(name='Keywords'),
  keywordLibId?: string(name='KeywordLibId'),
}

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

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

async function deleteKeywordWithOptions(request: DeleteKeywordRequest, runtime: Util.RuntimeOptions): DeleteKeywordResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteKeyword', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteKeyword(request: DeleteKeywordRequest): DeleteKeywordResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteKeywordWithOptions(request, runtime);
}

model DeleteKeywordLibRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  id?: int32(name='Id'),
}

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

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

async function deleteKeywordLibWithOptions(request: DeleteKeywordLibRequest, runtime: Util.RuntimeOptions): DeleteKeywordLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteKeywordLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteKeywordLib(request: DeleteKeywordLibRequest): DeleteKeywordLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteKeywordLibWithOptions(request, runtime);
}

model DeleteNotificationContactsRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  contactTypes?: string(name='ContactTypes'),
}

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

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

async function deleteNotificationContactsWithOptions(request: DeleteNotificationContactsRequest, runtime: Util.RuntimeOptions): DeleteNotificationContactsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DeleteNotificationContacts', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function deleteNotificationContacts(request: DeleteNotificationContactsRequest): DeleteNotificationContactsResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteNotificationContactsWithOptions(request, runtime);
}

model DescribeAppInfoRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  platform?: string(name='Platform'),
}

model DescribeAppInfoResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  appInfoList?: [ 
    {
      type?: int32(name='Type'),
      endDate?: string(name='EndDate'),
      packageName?: string(name='PackageName'),
      debugPackageInfo?: {
        version?: string(name='Version'),
      }(name='DebugPackageInfo'),
      icon?: string(name='Icon'),
      startDate?: string(name='StartDate'),
      packageInfo?: {
        version?: string(name='Version'),
      }(name='PackageInfo'),
      name?: string(name='Name'),
      id?: long(name='Id'),
    }
  ](name='AppInfoList'),
}

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

async function describeAppInfoWithOptions(request: DescribeAppInfoRequest, runtime: Util.RuntimeOptions): DescribeAppInfoResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeAppInfo', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeAppInfo(request: DescribeAppInfoRequest): DescribeAppInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAppInfoWithOptions(request, runtime);
}

model DescribeAuditCallbackResponseBody = {
  cryptType?: int32(name='CryptType'),
  callback?: string(name='Callback'),
  requestId?: string(name='RequestId'),
  seed?: string(name='Seed'),
}

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

async function describeAuditCallbackWithOptions(runtime: Util.RuntimeOptions): DescribeAuditCallbackResponse {
  var req = new OpenApi.OpenApiRequest{};
  return doRPCRequest('DescribeAuditCallback', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeAuditCallback(): DescribeAuditCallbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAuditCallbackWithOptions(runtime);
}

model DescribeAuditContentRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  startDate?: string(name='StartDate'),
  endDate?: string(name='EndDate'),
  scene?: string(name='Scene'),
  suggestion?: string(name='Suggestion'),
  label?: string(name='Label'),
  taskId?: string(name='TaskId'),
  dataId?: string(name='DataId'),
  bizType?: string(name='BizType'),
  auditResult?: string(name='AuditResult'),
  resourceType?: string(name='ResourceType'),
  imageId?: string(name='ImageId'),
  keywordId?: string(name='KeywordId'),
  libType?: string(name='LibType'),
}

model DescribeAuditContentResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  auditContentList?: [ 
    {
      suggestion?: string(name='Suggestion'),
      auditIllegalReasons?: [ string ](name='AuditIllegalReasons'),
      url?: string(name='Url'),
      dataId?: string(name='DataId'),
      results?: [ 
        {
          suggestion?: string(name='Suggestion'),
          label?: string(name='Label'),
          scene?: string(name='Scene'),
        }
      ](name='Results'),
      frameResults?: [ 
        {
          offset?: int32(name='Offset'),
          url?: string(name='Url'),
          label?: string(name='Label'),
        }
      ](name='FrameResults'),
      newUrl?: string(name='NewUrl'),
      bizType?: string(name='BizType'),
      scanFinishedTime?: string(name='ScanFinishedTime'),
      auditResult?: string(name='AuditResult'),
      taskId?: string(name='TaskId'),
      content?: string(name='Content'),
      audit?: int32(name='Audit'),
      thumbnail?: string(name='Thumbnail'),
      id?: long(name='Id'),
      requestTime?: string(name='RequestTime'),
    }
  ](name='AuditContentList'),
}

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

async function describeAuditContentWithOptions(request: DescribeAuditContentRequest, runtime: Util.RuntimeOptions): DescribeAuditContentResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeAuditContent', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeAuditContent(request: DescribeAuditContentRequest): DescribeAuditContentResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAuditContentWithOptions(request, runtime);
}

model DescribeAuditContentItemRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  taskId?: string(name='TaskId'),
  resourceType?: string(name='ResourceType'),
}

model DescribeAuditContentItemResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  pageSize?: int32(name='PageSize'),
  auditContentItemList?: [ 
    {
      endTime?: string(name='EndTime'),
      startTime?: string(name='StartTime'),
      suggestion?: string(name='Suggestion'),
      sn?: int32(name='Sn'),
      parentTaskId?: string(name='ParentTaskId'),
      auditIllegalReasons?: [ string ](name='AuditIllegalReasons'),
      auditResult?: string(name='AuditResult'),
      audit?: int32(name='Audit'),
      content?: string(name='Content'),
      id?: long(name='Id'),
    }
  ](name='AuditContentItemList'),
  currentPage?: int32(name='CurrentPage'),
}

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

async function describeAuditContentItemWithOptions(request: DescribeAuditContentItemRequest, runtime: Util.RuntimeOptions): DescribeAuditContentItemResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeAuditContentItem', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeAuditContentItem(request: DescribeAuditContentItemRequest): DescribeAuditContentItemResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAuditContentItemWithOptions(request, runtime);
}

model DescribeAuditRangeResponseBody = {
  auditRange?: {
    pass?: boolean(name='pass'),
    block?: boolean(name='block'),
    review?: boolean(name='review'),
  }(name='AuditRange'),
  requestId?: string(name='RequestId'),
}

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

async function describeAuditRangeWithOptions(runtime: Util.RuntimeOptions): DescribeAuditRangeResponse {
  var req = new OpenApi.OpenApiRequest{};
  return doRPCRequest('DescribeAuditRange', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeAuditRange(): DescribeAuditRangeResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAuditRangeWithOptions(runtime);
}

model DescribeAuditSettingRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
}

model DescribeAuditSettingResponseBody = {
  auditRange?: {
    pass?: boolean(name='pass'),
    block?: boolean(name='block'),
    review?: boolean(name='review'),
  }(name='AuditRange'),
  callback?: string(name='Callback'),
  requestId?: string(name='RequestId'),
  seed?: string(name='Seed'),
}

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

async function describeAuditSettingWithOptions(request: DescribeAuditSettingRequest, runtime: Util.RuntimeOptions): DescribeAuditSettingResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeAuditSetting', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeAuditSetting(request: DescribeAuditSettingRequest): DescribeAuditSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAuditSettingWithOptions(request, runtime);
}

model DescribeBizTypeImageLibRequest {
  bizTypeName?: string(name='BizTypeName'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
}

model DescribeBizTypeImageLibResponseBody = {
  white?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='White'),
  requestId?: string(name='RequestId'),
  black?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='Black'),
  review?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='Review'),
}

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

async function describeBizTypeImageLibWithOptions(request: DescribeBizTypeImageLibRequest, runtime: Util.RuntimeOptions): DescribeBizTypeImageLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeBizTypeImageLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeBizTypeImageLib(request: DescribeBizTypeImageLibRequest): DescribeBizTypeImageLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBizTypeImageLibWithOptions(request, runtime);
}

model DescribeBizTypesRequest {
  importFlag?: boolean(name='ImportFlag'),
}

model DescribeBizTypesResponseBody = {
  totalCount?: int32(name='TotalCount'),
  bizTypeList?: [ string ](name='BizTypeList'),
  requestId?: string(name='RequestId'),
}

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

async function describeBizTypesWithOptions(request: DescribeBizTypesRequest, runtime: Util.RuntimeOptions): DescribeBizTypesResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeBizTypes', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeBizTypes(request: DescribeBizTypesRequest): DescribeBizTypesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBizTypesWithOptions(request, runtime);
}

model DescribeBizTypeSettingRequest {
  bizTypeName?: string(name='BizTypeName'),
  resourceType?: string(name='ResourceType'),
}

model DescribeBizTypeSettingResponseBody = {
  antispam?: {
    categories?: [ string ](name='Categories'),
  }(name='Antispam'),
  ad?: {
    categories?: [ string ](name='Categories'),
  }(name='Ad'),
  requestId?: string(name='RequestId'),
  terrorism?: {
    categories?: [ string ](name='Categories'),
  }(name='Terrorism'),
  live?: {
    categories?: [ string ](name='Categories'),
  }(name='Live'),
  porn?: {
    categories?: [ string ](name='Categories'),
  }(name='Porn'),
}

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

async function describeBizTypeSettingWithOptions(request: DescribeBizTypeSettingRequest, runtime: Util.RuntimeOptions): DescribeBizTypeSettingResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeBizTypeSetting', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeBizTypeSetting(request: DescribeBizTypeSettingRequest): DescribeBizTypeSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBizTypeSettingWithOptions(request, runtime);
}

model DescribeBizTypeTextLibRequest {
  bizTypeName?: string(name='BizTypeName'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
}

model DescribeBizTypeTextLibResponseBody = {
  ignore?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='Ignore'),
  white?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='White'),
  requestId?: string(name='RequestId'),
  black?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='Black'),
  review?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='Review'),
}

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

async function describeBizTypeTextLibWithOptions(request: DescribeBizTypeTextLibRequest, runtime: Util.RuntimeOptions): DescribeBizTypeTextLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeBizTypeTextLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeBizTypeTextLib(request: DescribeBizTypeTextLibRequest): DescribeBizTypeTextLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBizTypeTextLibWithOptions(request, runtime);
}

model DescribeCloudMonitorServicesRequest {
  sourceIp?: string(name='SourceIp'),
  page?: string(name='Page'),
  pageSize?: string(name='PageSize'),
}

model DescribeCloudMonitorServicesResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  items?: [ string ](name='Items'),
}

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

async function describeCloudMonitorServicesWithOptions(request: DescribeCloudMonitorServicesRequest, runtime: Util.RuntimeOptions): DescribeCloudMonitorServicesResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeCloudMonitorServices', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeCloudMonitorServices(request: DescribeCloudMonitorServicesRequest): DescribeCloudMonitorServicesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeCloudMonitorServicesWithOptions(request, runtime);
}

model DescribeCustomOcrTemplateRequest {
  ids?: string(name='Ids'),
}

model DescribeCustomOcrTemplateResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  ocrTemplateList?: [ 
    {
      status?: int32(name='Status'),
      recognizeArea?: [ 
        {
          width?: int32(name='Width'),
          height?: int32(name='Height'),
          y?: int32(name='Y'),
          name?: string(name='Name'),
          x?: int32(name='X'),
        }
      ](name='RecognizeArea'),
      referArea?: [ 
        {
          width?: int32(name='Width'),
          height?: int32(name='Height'),
          y?: int32(name='Y'),
          name?: string(name='Name'),
          x?: int32(name='X'),
        }
      ](name='ReferArea'),
      imgUrl?: string(name='ImgUrl'),
      name?: string(name='Name'),
      id?: long(name='Id'),
    }
  ](name='OcrTemplateList'),
}

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

async function describeCustomOcrTemplateWithOptions(request: DescribeCustomOcrTemplateRequest, runtime: Util.RuntimeOptions): DescribeCustomOcrTemplateResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeCustomOcrTemplate', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeCustomOcrTemplate(request: DescribeCustomOcrTemplateRequest): DescribeCustomOcrTemplateResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeCustomOcrTemplateWithOptions(request, runtime);
}

model DescribeImageFromLibRequest {
  sourceIp?: string(name='SourceIp'),
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  imageLibId?: int32(name='ImageLibId'),
  id?: long(name='Id'),
  startDate?: string(name='StartDate'),
  endDate?: string(name='EndDate'),
}

model DescribeImageFromLibResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  imageFromLibList?: [ 
    {
      imageHitCount?: long(name='ImageHitCount'),
      image?: string(name='Image'),
      createTime?: string(name='CreateTime'),
      videoHitCount?: long(name='VideoHitCount'),
      thumbnail?: string(name='Thumbnail'),
      id?: long(name='Id'),
    }
  ](name='ImageFromLibList'),
}

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

async function describeImageFromLibWithOptions(request: DescribeImageFromLibRequest, runtime: Util.RuntimeOptions): DescribeImageFromLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeImageFromLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeImageFromLib(request: DescribeImageFromLibRequest): DescribeImageFromLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeImageFromLibWithOptions(request, runtime);
}

model DescribeImageLibRequest {
  sourceIp?: string(name='SourceIp'),
  serviceModule?: string(name='ServiceModule'),
}

model DescribeImageLibResponseBody = {
  totalCount?: int32(name='TotalCount'),
  imageLibList?: [ 
    {
      modifiedTime?: string(name='ModifiedTime'),
      code?: string(name='Code'),
      imageCount?: int32(name='ImageCount'),
      bizTypes?: [ string ](name='BizTypes'),
      category?: string(name='Category'),
      serviceModule?: string(name='ServiceModule'),
      source?: string(name='Source'),
      name?: string(name='Name'),
      scene?: string(name='Scene'),
      id?: int32(name='Id'),
      enable?: string(name='Enable'),
    }
  ](name='ImageLibList'),
  requestId?: string(name='RequestId'),
}

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

async function describeImageLibWithOptions(request: DescribeImageLibRequest, runtime: Util.RuntimeOptions): DescribeImageLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeImageLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeImageLib(request: DescribeImageLibRequest): DescribeImageLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeImageLibWithOptions(request, runtime);
}

model DescribeImageUploadInfoRequest {
  sourceIp?: string(name='SourceIp'),
}

model DescribeImageUploadInfoResponseBody = {
  policy?: string(name='Policy'),
  expire?: int32(name='Expire'),
  requestId?: string(name='RequestId'),
  accessid?: string(name='Accessid'),
  signature?: string(name='Signature'),
  host?: string(name='Host'),
  folder?: string(name='Folder'),
}

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

async function describeImageUploadInfoWithOptions(request: DescribeImageUploadInfoRequest, runtime: Util.RuntimeOptions): DescribeImageUploadInfoResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeImageUploadInfo', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeImageUploadInfo(request: DescribeImageUploadInfoRequest): DescribeImageUploadInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeImageUploadInfoWithOptions(request, runtime);
}

model DescribeKeywordRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  keywordLibId?: int32(name='KeywordLibId'),
  keyword?: string(name='Keyword'),
}

model DescribeKeywordResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  keywordList?: [ 
    {
      hitCount?: int32(name='HitCount'),
      keyword?: string(name='Keyword'),
      createTime?: string(name='CreateTime'),
      id?: int32(name='Id'),
    }
  ](name='KeywordList'),
}

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

async function describeKeywordWithOptions(request: DescribeKeywordRequest, runtime: Util.RuntimeOptions): DescribeKeywordResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeKeyword', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeKeyword(request: DescribeKeywordRequest): DescribeKeywordResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeKeywordWithOptions(request, runtime);
}

model DescribeKeywordLibRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  serviceModule?: string(name='ServiceModule'),
}

model DescribeKeywordLibResponseBody = {
  totalCount?: int32(name='TotalCount'),
  keywordLibList?: [ 
    {
      source?: string(name='Source'),
      language?: string(name='Language'),
      count?: int32(name='Count'),
      libType?: string(name='LibType'),
      resourceType?: string(name='ResourceType'),
      modifiedTime?: string(name='ModifiedTime'),
      code?: string(name='Code'),
      bizTypes?: [ string ](name='BizTypes'),
      category?: string(name='Category'),
      serviceModule?: string(name='ServiceModule'),
      name?: string(name='Name'),
      matchMode?: string(name='MatchMode'),
      id?: int32(name='Id'),
      enable?: boolean(name='Enable'),
    }
  ](name='KeywordLibList'),
  requestId?: string(name='RequestId'),
}

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

async function describeKeywordLibWithOptions(request: DescribeKeywordLibRequest, runtime: Util.RuntimeOptions): DescribeKeywordLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeKeywordLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeKeywordLib(request: DescribeKeywordLibRequest): DescribeKeywordLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeKeywordLibWithOptions(request, runtime);
}

model DescribeNotificationSettingRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
}

model DescribeNotificationSettingResponseBody = {
  email?: string(name='Email'),
  requestId?: string(name='RequestId'),
  phone?: string(name='Phone'),
  scheduleMessageTime?: int32(name='ScheduleMessageTime'),
  scheduleMessageTimeZone?: int32(name='ScheduleMessageTimeZone'),
  reminderModeList?: [ string ](name='ReminderModeList'),
  realtimeMessageList?: [ string ](name='RealtimeMessageList'),
}

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

async function describeNotificationSettingWithOptions(request: DescribeNotificationSettingRequest, runtime: Util.RuntimeOptions): DescribeNotificationSettingResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeNotificationSetting', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeNotificationSetting(request: DescribeNotificationSettingRequest): DescribeNotificationSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeNotificationSettingWithOptions(request, runtime);
}

model DescribeOpenApiRcpStatsRequest {
  startDate?: string(name='StartDate'),
  endDate?: string(name='EndDate'),
  resourceType?: string(name='ResourceType'),
  bizType?: string(name='BizType'),
}

model DescribeOpenApiRcpStatsResponseBody = {
  totalCount?: int32(name='TotalCount'),
  statList?: [ 
    {
      resourceType?: string(name='ResourceType'),
      passCount?: int32(name='PassCount'),
      date?: string(name='Date'),
      totalCount?: int32(name='TotalCount'),
      blockCount?: int32(name='BlockCount'),
      totalDuration?: int32(name='TotalDuration'),
      reviewCount?: int32(name='ReviewCount'),
    }
  ](name='StatList'),
  requestId?: string(name='RequestId'),
}

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

async function describeOpenApiRcpStatsWithOptions(request: DescribeOpenApiRcpStatsRequest, runtime: Util.RuntimeOptions): DescribeOpenApiRcpStatsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeOpenApiRcpStats', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeOpenApiRcpStats(request: DescribeOpenApiRcpStatsRequest): DescribeOpenApiRcpStatsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOpenApiRcpStatsWithOptions(request, runtime);
}

model DescribeOpenApiUsageRequest {
  sourceIp?: string(name='SourceIp'),
  startDate?: string(name='StartDate'),
  endDate?: string(name='EndDate'),
  resourceType?: string(name='ResourceType'),
}

model DescribeOpenApiUsageResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  openApiUsageList?: [ 
    {
      passDuration?: int32(name='PassDuration'),
      reviewDuration?: int32(name='ReviewDuration'),
      outerTotalCount?: int32(name='OuterTotalCount'),
      date?: string(name='Date'),
      totalCount?: int32(name='TotalCount'),
      reviewCount?: int32(name='ReviewCount'),
      innerTotalCount?: int32(name='InnerTotalCount'),
      passCount?: int32(name='PassCount'),
      resourceType?: string(name='ResourceType'),
      blockDuration?: int32(name='BlockDuration'),
      blockCount?: int32(name='BlockCount'),
      scene?: string(name='Scene'),
      totalDuration?: int32(name='TotalDuration'),
    }
  ](name='OpenApiUsageList'),
}

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

async function describeOpenApiUsageWithOptions(request: DescribeOpenApiUsageRequest, runtime: Util.RuntimeOptions): DescribeOpenApiUsageResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeOpenApiUsage', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeOpenApiUsage(request: DescribeOpenApiUsageRequest): DescribeOpenApiUsageResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOpenApiUsageWithOptions(request, runtime);
}

model DescribeOssCallbackSettingResponseBody = {
  callbackUrl?: string(name='CallbackUrl'),
  scanCallbackSuggestions?: [ string ](name='ScanCallbackSuggestions'),
  auditCallback?: boolean(name='AuditCallback'),
  requestId?: string(name='RequestId'),
  scanCallback?: boolean(name='ScanCallback'),
  serviceModules?: [ string ](name='ServiceModules'),
  callbackSeed?: string(name='CallbackSeed'),
}

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

async function describeOssCallbackSettingWithOptions(runtime: Util.RuntimeOptions): DescribeOssCallbackSettingResponse {
  var req = new OpenApi.OpenApiRequest{};
  return doRPCRequest('DescribeOssCallbackSetting', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeOssCallbackSetting(): DescribeOssCallbackSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssCallbackSettingWithOptions(runtime);
}

model DescribeOssIncrementCheckSettingRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
}

model DescribeOssIncrementCheckSettingResponseBody = {
  audioMaxSize?: int32(name='AudioMaxSize'),
  videoAutoFreezeSceneList?: [ string ](name='VideoAutoFreezeSceneList'),
  requestId?: string(name='RequestId'),
  audioAntispamFreezeConfig?: {
    type?: string(name='Type'),
    value?: string(name='Value'),
  }(name='AudioAntispamFreezeConfig'),
  callbackId?: string(name='CallbackId'),
  imageScanLimit?: long(name='ImageScanLimit'),
  scanImageNoFileType?: boolean(name='ScanImageNoFileType'),
  audioSceneList?: [ string ](name='AudioSceneList'),
  imageAutoFreeze?: {
    live?: string(name='Live'),
    ad?: string(name='Ad'),
    terrorism?: string(name='Terrorism'),
    enabled?: boolean(name='Enabled'),
    porn?: string(name='Porn'),
  }(name='ImageAutoFreeze'),
  bucketConfigList?: [ 
    {
      prefixes?: [ string ](name='Prefixes'),
      selected?: boolean(name='Selected'),
      bucket?: string(name='Bucket'),
    }
  ](name='BucketConfigList'),
  videoFrameInterval?: int32(name='VideoFrameInterval'),
  audioAutoFreezeOpened?: boolean(name='AudioAutoFreezeOpened'),
  imageEnableLimit?: boolean(name='ImageEnableLimit'),
  videoSceneList?: [ string ](name='VideoSceneList'),
  callbackName?: string(name='CallbackName'),
  imageSceneList?: [ string ](name='ImageSceneList'),
  autoFreezeType?: string(name='AutoFreezeType'),
  videoMaxFrames?: int32(name='VideoMaxFrames'),
  videoMaxSize?: int32(name='VideoMaxSize'),
}

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

async function describeOssIncrementCheckSettingWithOptions(request: DescribeOssIncrementCheckSettingRequest, runtime: Util.RuntimeOptions): DescribeOssIncrementCheckSettingResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeOssIncrementCheckSetting', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeOssIncrementCheckSetting(request: DescribeOssIncrementCheckSettingRequest): DescribeOssIncrementCheckSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssIncrementCheckSettingWithOptions(request, runtime);
}

model DescribeOssIncrementOverviewRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
}

model DescribeOssIncrementOverviewResponseBody = {
  videoCount?: int32(name='VideoCount'),
  imageCount?: int32(name='ImageCount'),
  voiceAntispamUnhandleCount?: int32(name='VoiceAntispamUnhandleCount'),
  requestId?: string(name='RequestId'),
  pornUnhandleCount?: int32(name='PornUnhandleCount'),
  liveUnhandleCount?: int32(name='LiveUnhandleCount'),
  audioCount?: int32(name='AudioCount'),
  adUnhandleCount?: int32(name='AdUnhandleCount'),
  videoFrameCount?: int32(name='VideoFrameCount'),
  terrorismUnhandleCount?: int32(name='TerrorismUnhandleCount'),
}

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

async function describeOssIncrementOverviewWithOptions(request: DescribeOssIncrementOverviewRequest, runtime: Util.RuntimeOptions): DescribeOssIncrementOverviewResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeOssIncrementOverview', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeOssIncrementOverview(request: DescribeOssIncrementOverviewRequest): DescribeOssIncrementOverviewResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssIncrementOverviewWithOptions(request, runtime);
}

model DescribeOssIncrementStatsRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
  startDate?: string(name='StartDate'),
  endDate?: string(name='EndDate'),
}

model DescribeOssIncrementStatsResponseBody = {
  totalCount?: int32(name='TotalCount'),
  statList?: [ 
    {
      resourceType?: string(name='ResourceType'),
      passCount?: int32(name='PassCount'),
      date?: string(name='Date'),
      totalCount?: int32(name='TotalCount'),
      blockCount?: int32(name='BlockCount'),
      scene?: string(name='Scene'),
      reviewCount?: int32(name='ReviewCount'),
    }
  ](name='StatList'),
  requestId?: string(name='RequestId'),
}

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

async function describeOssIncrementStatsWithOptions(request: DescribeOssIncrementStatsRequest, runtime: Util.RuntimeOptions): DescribeOssIncrementStatsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeOssIncrementStats', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeOssIncrementStats(request: DescribeOssIncrementStatsRequest): DescribeOssIncrementStatsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssIncrementStatsWithOptions(request, runtime);
}

model DescribeOssResultItemsRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  startDate?: string(name='StartDate'),
  endDate?: string(name='EndDate'),
  scene?: string(name='Scene'),
  suggestion?: string(name='Suggestion'),
  stock?: boolean(name='Stock'),
  minScore?: float(name='MinScore'),
  maxScore?: float(name='MaxScore'),
  resourceType?: string(name='ResourceType'),
  bucket?: string(name='Bucket'),
  queryId?: string(name='QueryId'),
  object?: string(name='Object'),
  stockTaskId?: long(name='StockTaskId'),
}

model DescribeOssResultItemsResponseBody = {
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  currentPage?: int32(name='CurrentPage'),
  queryId?: string(name='QueryId'),
  scanResultList?: [ 
    {
      suggestion?: string(name='Suggestion'),
      createTime?: string(name='CreateTime'),
      score?: string(name='Score'),
      object?: string(name='Object'),
      dataId?: string(name='DataId'),
      frameResults?: [ 
        {
          offset?: int32(name='Offset'),
          url?: string(name='Url'),
          thumbnail?: string(name='Thumbnail'),
        }
      ](name='FrameResults'),
      newUrl?: string(name='NewUrl'),
      voiceSegmentAntispamResults?: [ 
        {
          endTime?: int32(name='EndTime'),
          startTime?: int32(name='StartTime'),
          text?: string(name='Text'),
          label?: string(name='Label'),
        }
      ](name='VoiceSegmentAntispamResults'),
      scanFinishedTime?: string(name='ScanFinishedTime'),
      handleStatus?: int32(name='HandleStatus'),
      content?: string(name='Content'),
      thumbnail?: string(name='Thumbnail'),
      taskId?: string(name='TaskId'),
      id?: long(name='Id'),
      resourceStatus?: int32(name='ResourceStatus'),
      requestTime?: string(name='RequestTime'),
      bucket?: string(name='Bucket'),
    }
  ](name='ScanResultList'),
}

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

async function describeOssResultItemsWithOptions(request: DescribeOssResultItemsRequest, runtime: Util.RuntimeOptions): DescribeOssResultItemsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeOssResultItems', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeOssResultItems(request: DescribeOssResultItemsRequest): DescribeOssResultItemsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssResultItemsWithOptions(request, runtime);
}

model DescribeOssStockStatusRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  stockTaskId?: long(name='StockTaskId'),
}

model DescribeOssStockStatusResponseBody = {
  audioTotalCount?: int32(name='AudioTotalCount'),
  imageTerrorismCount?: int32(name='ImageTerrorismCount'),
  videoPornCount?: int32(name='VideoPornCount'),
  imagePornCount?: int32(name='ImagePornCount'),
  audioAntispamCount?: int32(name='AudioAntispamCount'),
  requestId?: string(name='RequestId'),
  videoLiveCount?: int32(name='VideoLiveCount'),
  imageAdCount?: int32(name='ImageAdCount'),
  sceneList?: [ string ](name='SceneList'),
  finishedTime?: string(name='FinishedTime'),
  bucketList?: [ 
    {
      prefixes?: [ string ](name='Prefixes'),
      selected?: boolean(name='Selected'),
      bucket?: string(name='Bucket'),
    }
  ](name='BucketList'),
  stockStatus?: int32(name='StockStatus'),
  videoTotalCount?: int32(name='VideoTotalCount'),
  imageTotalCount?: int32(name='ImageTotalCount'),
  imageLiveCount?: int32(name='ImageLiveCount'),
  videoAdCount?: int32(name='VideoAdCount'),
  videoVoiceAntispamCount?: int32(name='VideoVoiceAntispamCount'),
  videoTerrorismCount?: int32(name='VideoTerrorismCount'),
  resouceTypeList?: [ string ](name='ResouceTypeList'),
}

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

async function describeOssStockStatusWithOptions(request: DescribeOssStockStatusRequest, runtime: Util.RuntimeOptions): DescribeOssStockStatusResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeOssStockStatus', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeOssStockStatus(request: DescribeOssStockStatusRequest): DescribeOssStockStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssStockStatusWithOptions(request, runtime);
}

model DescribeSdkUrlRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  id?: long(name='Id'),
  debug?: boolean(name='Debug'),
}

model DescribeSdkUrlResponseBody = {
  sdkUrl?: string(name='SdkUrl'),
  requestId?: string(name='RequestId'),
}

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

async function describeSdkUrlWithOptions(request: DescribeSdkUrlRequest, runtime: Util.RuntimeOptions): DescribeSdkUrlResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeSdkUrl', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeSdkUrl(request: DescribeSdkUrlRequest): DescribeSdkUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSdkUrlWithOptions(request, runtime);
}

model DescribeUpdatePackageResultRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  taskId?: string(name='TaskId'),
}

model DescribeUpdatePackageResultResponseBody = {
  requestId?: string(name='RequestId'),
  appInfo?: {
    type?: int32(name='Type'),
    endDate?: string(name='EndDate'),
    packageName?: string(name='PackageName'),
    debugPackageInfo?: {
      version?: string(name='Version'),
    }(name='DebugPackageInfo'),
    icon?: string(name='Icon'),
    startDate?: string(name='StartDate'),
    packageInfo?: {
      version?: string(name='Version'),
    }(name='PackageInfo'),
    name?: string(name='Name'),
    id?: long(name='Id'),
  }(name='AppInfo'),
}

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

async function describeUpdatePackageResultWithOptions(request: DescribeUpdatePackageResultRequest, runtime: Util.RuntimeOptions): DescribeUpdatePackageResultResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeUpdatePackageResult', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUpdatePackageResult(request: DescribeUpdatePackageResultRequest): DescribeUpdatePackageResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUpdatePackageResultWithOptions(request, runtime);
}

model DescribeUploadInfoRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  biz?: string(name='Biz'),
}

model DescribeUploadInfoResponseBody = {
  policy?: string(name='Policy'),
  expire?: int32(name='Expire'),
  requestId?: string(name='RequestId'),
  accessid?: string(name='Accessid'),
  signature?: string(name='Signature'),
  host?: string(name='Host'),
  folder?: string(name='Folder'),
}

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

async function describeUploadInfoWithOptions(request: DescribeUploadInfoRequest, runtime: Util.RuntimeOptions): DescribeUploadInfoResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeUploadInfo', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUploadInfo(request: DescribeUploadInfoRequest): DescribeUploadInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUploadInfoWithOptions(request, runtime);
}

model DescribeUsageBillRequest {
  type?: string(name='Type'),
  day?: string(name='Day'),
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
}

model DescribeUsageBillResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  billList?: [ 
    {
      day?: string(name='Day'),
      subUid?: string(name='SubUid'),
      region?: string(name='Region'),
      confirmCount?: long(name='ConfirmCount'),
      totalCount?: long(name='TotalCount'),
      scene?: string(name='Scene'),
      bizType?: string(name='BizType'),
      freeCount?: long(name='FreeCount'),
      reviewCount?: long(name='ReviewCount'),
    }
  ](name='BillList'),
}

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

async function describeUsageBillWithOptions(request: DescribeUsageBillRequest, runtime: Util.RuntimeOptions): DescribeUsageBillResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeUsageBill', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUsageBill(request: DescribeUsageBillRequest): DescribeUsageBillResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUsageBillWithOptions(request, runtime);
}

model DescribeUserBizTypesRequest {
  customized?: boolean(name='Customized'),
}

model DescribeUserBizTypesResponseBody = {
  bizTypeList?: [ 
    {
      industryInfo?: string(name='IndustryInfo'),
      description?: string(name='Description'),
      citeTemplate?: boolean(name='CiteTemplate'),
      sourceBizType?: string(name='SourceBizType'),
      gray?: boolean(name='Gray'),
      source?: string(name='Source'),
      bizType?: string(name='BizType'),
    }
  ](name='BizTypeList'),
  requestId?: string(name='RequestId'),
  bizTypeListImport?: [ 
    {
      industryInfo?: string(name='IndustryInfo'),
      description?: string(name='Description'),
      citeTemplate?: boolean(name='CiteTemplate'),
      sourceBizType?: string(name='SourceBizType'),
      gray?: boolean(name='Gray'),
      source?: string(name='Source'),
      bizType?: string(name='BizType'),
    }
  ](name='BizTypeListImport'),
}

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

async function describeUserBizTypesWithOptions(request: DescribeUserBizTypesRequest, runtime: Util.RuntimeOptions): DescribeUserBizTypesResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeUserBizTypes', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUserBizTypes(request: DescribeUserBizTypesRequest): DescribeUserBizTypesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUserBizTypesWithOptions(request, runtime);
}

model DescribeUserStatusRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
}

model DescribeUserStatusResponseBody = {
  openApiBeginTime?: string(name='OpenApiBeginTime'),
  uid?: string(name='Uid'),
  requestId?: string(name='RequestId'),
  openApiUsed?: boolean(name='OpenApiUsed'),
  ossCheckStatus?: string(name='OssCheckStatus'),
  ossVideoSizeLimit?: int32(name='OssVideoSizeLimit'),
  inDept?: boolean(name='InDept'),
  buyed?: boolean(name='Buyed'),
}

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

async function describeUserStatusWithOptions(request: DescribeUserStatusRequest, runtime: Util.RuntimeOptions): DescribeUserStatusResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeUserStatus', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeUserStatus(request: DescribeUserStatusRequest): DescribeUserStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUserStatusWithOptions(request, runtime);
}

model DescribeViewContentRequest {
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  startDate?: string(name='StartDate'),
  endDate?: string(name='EndDate'),
  scene?: string(name='Scene'),
  suggestion?: string(name='Suggestion'),
  label?: string(name='Label'),
  taskId?: string(name='TaskId'),
  dataId?: string(name='DataId'),
  bizType?: string(name='BizType'),
  auditResult?: string(name='AuditResult'),
  resourceType?: string(name='ResourceType'),
  imageId?: string(name='ImageId'),
  keywordId?: string(name='KeywordId'),
  libType?: string(name='LibType'),
  keyword?: string(name='Keyword'),
}

model DescribeViewContentResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  pageSize?: int32(name='PageSize'),
  viewContentList?: [ 
    {
      suggestion?: string(name='Suggestion'),
      scanResult?: string(name='ScanResult'),
      faceResults?: [ 
        {
          image?: {
            width?: int32(name='Width'),
            height?: int32(name='Height'),
          }(name='Image'),
          gender?: {
            value?: string(name='Value'),
            rate?: float(name='Rate'),
          }(name='Gender'),
          mustache?: {
            value?: string(name='Value'),
            rate?: float(name='Rate'),
          }(name='Mustache'),
          bang?: {
            value?: string(name='Value'),
            rate?: float(name='Rate'),
          }(name='Bang'),
          age?: {
            value?: int32(name='Value'),
            rate?: float(name='Rate'),
          }(name='Age'),
          hairstyle?: {
            value?: string(name='Value'),
            rate?: float(name='Rate'),
          }(name='Hairstyle'),
          quality?: {
            roll?: float(name='Roll'),
            pitch?: float(name='Pitch'),
            yaw?: float(name='Yaw'),
            blur?: float(name='Blur'),
          }(name='Quality'),
          bualified?: boolean(name='Bualified'),
          glasses?: {
            value?: string(name='Value'),
            rate?: float(name='Rate'),
          }(name='Glasses'),
          hat?: {
            value?: string(name='Value'),
            rate?: float(name='Rate'),
          }(name='Hat'),
          respirator?: {
            value?: string(name='Value'),
            rate?: float(name='Rate'),
          }(name='Respirator'),
          smile?: {
            value?: float(name='Value'),
            rate?: float(name='Rate'),
          }(name='Smile'),
          location?: {
            w?: int32(name='W'),
            h?: int32(name='H'),
            y?: int32(name='Y'),
            x?: int32(name='X'),
          }(name='Location'),
        }
      ](name='FaceResults'),
      url?: string(name='Url'),
      dataId?: string(name='DataId'),
      frameResults?: [ 
        {
          offset?: int32(name='Offset'),
          url?: string(name='Url'),
          label?: string(name='Label'),
        }
      ](name='FrameResults'),
      results?: [ 
        {
          suggestion?: string(name='Suggestion'),
          label?: string(name='Label'),
          scene?: string(name='Scene'),
        }
      ](name='Results'),
      newUrl?: string(name='NewUrl'),
      bizType?: string(name='BizType'),
      scanFinishedTime?: string(name='ScanFinishedTime'),
      taskId?: string(name='TaskId'),
      thumbnail?: string(name='Thumbnail'),
      content?: string(name='Content'),
      id?: long(name='Id'),
      requestTime?: string(name='RequestTime'),
    }
  ](name='ViewContentList'),
  currentPage?: int32(name='CurrentPage'),
}

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

async function describeViewContentWithOptions(request: DescribeViewContentRequest, runtime: Util.RuntimeOptions): DescribeViewContentResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeViewContent', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeViewContent(request: DescribeViewContentRequest): DescribeViewContentResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeViewContentWithOptions(request, runtime);
}

model DescribeWebsiteIndexPageBaselineRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  instanceId?: string(name='InstanceId'),
}

model DescribeWebsiteIndexPageBaselineResponseBody = {
  snapshot?: string(name='Snapshot'),
  baseLineStatus?: string(name='BaseLineStatus'),
  requestId?: string(name='RequestId'),
  createTime?: string(name='CreateTime'),
}

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

async function describeWebsiteIndexPageBaselineWithOptions(request: DescribeWebsiteIndexPageBaselineRequest, runtime: Util.RuntimeOptions): DescribeWebsiteIndexPageBaselineResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeWebsiteIndexPageBaseline', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeWebsiteIndexPageBaseline(request: DescribeWebsiteIndexPageBaselineRequest): DescribeWebsiteIndexPageBaselineResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteIndexPageBaselineWithOptions(request, runtime);
}

model DescribeWebsiteInstanceRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  instanceId?: string(name='InstanceId'),
}

model DescribeWebsiteInstanceResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  websiteInstanceList?: [ 
    {
      status?: string(name='Status'),
      domain?: string(name='Domain'),
      indexPage?: string(name='IndexPage'),
      expiredTime?: string(name='ExpiredTime'),
      websiteScanInterval?: int32(name='WebsiteScanInterval'),
      protocol?: string(name='Protocol'),
      buyTime?: string(name='BuyTime'),
      instanceId?: string(name='InstanceId'),
      indexPageScanInterval?: int32(name='IndexPageScanInterval'),
    }
  ](name='WebsiteInstanceList'),
}

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

async function describeWebsiteInstanceWithOptions(request: DescribeWebsiteInstanceRequest, runtime: Util.RuntimeOptions): DescribeWebsiteInstanceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeWebsiteInstance', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeWebsiteInstance(request: DescribeWebsiteInstanceRequest): DescribeWebsiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteInstanceWithOptions(request, runtime);
}

model DescribeWebsiteInstanceIdRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
}

model DescribeWebsiteInstanceIdResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  websiteInstanceIdList?: [ string ](name='WebsiteInstanceIdList'),
}

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

async function describeWebsiteInstanceIdWithOptions(request: DescribeWebsiteInstanceIdRequest, runtime: Util.RuntimeOptions): DescribeWebsiteInstanceIdResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeWebsiteInstanceId', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeWebsiteInstanceId(request: DescribeWebsiteInstanceIdRequest): DescribeWebsiteInstanceIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteInstanceIdWithOptions(request, runtime);
}

model DescribeWebsiteInstanceKeyUrlRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  instanceId?: string(name='InstanceId'),
}

model DescribeWebsiteInstanceKeyUrlResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  websiteInstanceKeyUrlList?: [ string ](name='WebsiteInstanceKeyUrlList'),
}

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

async function describeWebsiteInstanceKeyUrlWithOptions(request: DescribeWebsiteInstanceKeyUrlRequest, runtime: Util.RuntimeOptions): DescribeWebsiteInstanceKeyUrlResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeWebsiteInstanceKeyUrl', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeWebsiteInstanceKeyUrl(request: DescribeWebsiteInstanceKeyUrlRequest): DescribeWebsiteInstanceKeyUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteInstanceKeyUrlWithOptions(request, runtime);
}

model DescribeWebsiteScanResultRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  subServiceModule?: string(name='SubServiceModule'),
  label?: string(name='Label'),
  domain?: string(name='Domain'),
  siteUrl?: string(name='SiteUrl'),
  handleStatus?: string(name='HandleStatus'),
}

model DescribeWebsiteScanResultResponseBody = {
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  websiteScanResultList?: [ 
    {
      scanTime?: string(name='ScanTime'),
      domain?: string(name='Domain'),
      sourceRiskCount?: int32(name='SourceRiskCount'),
      labels?: [ string ](name='Labels'),
      imageRiskCount?: int32(name='ImageRiskCount'),
      url?: string(name='Url'),
      textRiskCount?: int32(name='TextRiskCount'),
      handleStatus?: int32(name='HandleStatus'),
      instanceId?: string(name='InstanceId'),
      taskId?: string(name='TaskId'),
      id?: int32(name='Id'),
    }
  ](name='WebsiteScanResultList'),
}

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

async function describeWebsiteScanResultWithOptions(request: DescribeWebsiteScanResultRequest, runtime: Util.RuntimeOptions): DescribeWebsiteScanResultResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeWebsiteScanResult', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeWebsiteScanResult(request: DescribeWebsiteScanResultRequest): DescribeWebsiteScanResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteScanResultWithOptions(request, runtime);
}

model DescribeWebsiteScanResultDetailRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  id?: int32(name='Id'),
  resourceType?: string(name='ResourceType'),
}

model DescribeWebsiteScanResultDetailResponseBody = {
  hitKeywords?: [ string ](name='HitKeywords'),
  requestId?: string(name='RequestId'),
  imageScanResults?: [ 
    {
      labels?: [ string ](name='Labels'),
      url?: string(name='Url'),
    }
  ](name='ImageScanResults'),
  content?: string(name='Content'),
  resourceType?: string(name='ResourceType'),
  baseline?: string(name='Baseline'),
  tamperedSource?: string(name='TamperedSource'),
}

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

async function describeWebsiteScanResultDetailWithOptions(request: DescribeWebsiteScanResultDetailRequest, runtime: Util.RuntimeOptions): DescribeWebsiteScanResultDetailResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeWebsiteScanResultDetail', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeWebsiteScanResultDetail(request: DescribeWebsiteScanResultDetailRequest): DescribeWebsiteScanResultDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteScanResultDetailWithOptions(request, runtime);
}

model DescribeWebsiteStatRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
}

model DescribeWebsiteStatResponseBody = {
  websiteStatList?: [ 
    {
      scanCount?: int32(name='ScanCount'),
      instanceCount?: int32(name='InstanceCount'),
      riskCount?: int32(name='RiskCount'),
      subServiceModule?: string(name='SubServiceModule'),
    }
  ](name='WebsiteStatList'),
  totalCount?: int32(name='TotalCount'),
  requestId?: string(name='RequestId'),
}

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

async function describeWebsiteStatWithOptions(request: DescribeWebsiteStatRequest, runtime: Util.RuntimeOptions): DescribeWebsiteStatResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeWebsiteStat', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeWebsiteStat(request: DescribeWebsiteStatRequest): DescribeWebsiteStatResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteStatWithOptions(request, runtime);
}

model DescribeWebsiteVerifyInfoRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  instanceId?: string(name='InstanceId'),
}

model DescribeWebsiteVerifyInfoResponseBody = {
  requestId?: string(name='RequestId'),
  verifyMethod?: string(name='VerifyMethod'),
  domain?: string(name='Domain'),
  protocol?: string(name='Protocol'),
  cname?: string(name='Cname'),
  hostFile?: string(name='HostFile'),
  indexPage?: string(name='IndexPage'),
}

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

async function describeWebsiteVerifyInfoWithOptions(request: DescribeWebsiteVerifyInfoRequest, runtime: Util.RuntimeOptions): DescribeWebsiteVerifyInfoResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeWebsiteVerifyInfo', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeWebsiteVerifyInfo(request: DescribeWebsiteVerifyInfoRequest): DescribeWebsiteVerifyInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteVerifyInfoWithOptions(request, runtime);
}

model ExportKeywordsRequest {
  keywordLibId?: long(name='KeywordLibId'),
}

model ExportKeywordsResponseBody = {
  requestId?: string(name='RequestId'),
  downloadUrl?: string(name='DownloadUrl'),
}

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

async function exportKeywordsWithOptions(request: ExportKeywordsRequest, runtime: Util.RuntimeOptions): ExportKeywordsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ExportKeywords', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function exportKeywords(request: ExportKeywordsRequest): ExportKeywordsResponse {
  var runtime = new Util.RuntimeOptions{};
  return exportKeywordsWithOptions(request, runtime);
}

model ExportOpenApiRcpStatsRequest {
  startDate?: string(name='StartDate'),
  endDate?: string(name='EndDate'),
  resourceType?: string(name='ResourceType'),
  bizType?: string(name='BizType'),
}

model ExportOpenApiRcpStatsResponseBody = {
  requestId?: string(name='RequestId'),
  downloadUrl?: string(name='DownloadUrl'),
}

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

async function exportOpenApiRcpStatsWithOptions(request: ExportOpenApiRcpStatsRequest, runtime: Util.RuntimeOptions): ExportOpenApiRcpStatsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ExportOpenApiRcpStats', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function exportOpenApiRcpStats(request: ExportOpenApiRcpStatsRequest): ExportOpenApiRcpStatsResponse {
  var runtime = new Util.RuntimeOptions{};
  return exportOpenApiRcpStatsWithOptions(request, runtime);
}

model ExportOssResultRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  totalCount?: int32(name='TotalCount'),
  pageSize?: int32(name='PageSize'),
  currentPage?: int32(name='CurrentPage'),
  startDate?: string(name='StartDate'),
  endDate?: string(name='EndDate'),
  scene?: string(name='Scene'),
  suggestion?: string(name='Suggestion'),
  stock?: boolean(name='Stock'),
  minScore?: float(name='MinScore'),
  maxScore?: float(name='MaxScore'),
  resourceType?: string(name='ResourceType'),
  bucket?: string(name='Bucket'),
  stockTaskId?: long(name='StockTaskId'),
}

model ExportOssResultResponseBody = {
  fileUrl?: string(name='FileUrl'),
  requestId?: string(name='RequestId'),
}

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

async function exportOssResultWithOptions(request: ExportOssResultRequest, runtime: Util.RuntimeOptions): ExportOssResultResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ExportOssResult', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function exportOssResult(request: ExportOssResultRequest): ExportOssResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return exportOssResultWithOptions(request, runtime);
}

model ImportKeywordsRequest {
  keywordLibId?: int32(name='KeywordLibId'),
  keywordsObject?: string(name='KeywordsObject'),
}

model ImportKeywordsResponseBody = {
  requestId?: string(name='RequestId'),
  invalidKeywordList?: [ string ](name='InvalidKeywordList'),
  validKeywordList?: [ string ](name='validKeywordList'),
  successCount?: int32(name='SuccessCount'),
}

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

async function importKeywordsWithOptions(request: ImportKeywordsRequest, runtime: Util.RuntimeOptions): ImportKeywordsResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ImportKeywords', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function importKeywords(request: ImportKeywordsRequest): ImportKeywordsResponse {
  var runtime = new Util.RuntimeOptions{};
  return importKeywordsWithOptions(request, runtime);
}

model MarkAuditContentRequest {
  sourceIp?: string(name='SourceIp'),
  ids?: string(name='Ids'),
  auditResult?: string(name='AuditResult'),
  auditIllegalReasons?: string(name='AuditIllegalReasons'),
  bizTypes?: string(name='BizTypes'),
}

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

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

async function markAuditContentWithOptions(request: MarkAuditContentRequest, runtime: Util.RuntimeOptions): MarkAuditContentResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('MarkAuditContent', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function markAuditContent(request: MarkAuditContentRequest): MarkAuditContentResponse {
  var runtime = new Util.RuntimeOptions{};
  return markAuditContentWithOptions(request, runtime);
}

model MarkAuditContentItemRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  ids?: string(name='Ids'),
  auditResult?: string(name='AuditResult'),
  auditIllegalReasons?: string(name='AuditIllegalReasons'),
  bizTypes?: string(name='BizTypes'),
}

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

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

async function markAuditContentItemWithOptions(request: MarkAuditContentItemRequest, runtime: Util.RuntimeOptions): MarkAuditContentItemResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('MarkAuditContentItem', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function markAuditContentItem(request: MarkAuditContentItemRequest): MarkAuditContentItemResponse {
  var runtime = new Util.RuntimeOptions{};
  return markAuditContentItemWithOptions(request, runtime);
}

model MarkOssResultRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  ids?: string(name='Ids'),
  operation?: string(name='Operation'),
  stock?: boolean(name='Stock'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
}

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

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

async function markOssResultWithOptions(request: MarkOssResultRequest, runtime: Util.RuntimeOptions): MarkOssResultResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('MarkOssResult', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function markOssResult(request: MarkOssResultRequest): MarkOssResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return markOssResultWithOptions(request, runtime);
}

model MarkWebsiteScanResultRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  ids?: string(name='Ids'),
}

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

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

async function markWebsiteScanResultWithOptions(request: MarkWebsiteScanResultRequest, runtime: Util.RuntimeOptions): MarkWebsiteScanResultResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('MarkWebsiteScanResult', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function markWebsiteScanResult(request: MarkWebsiteScanResultRequest): MarkWebsiteScanResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return markWebsiteScanResultWithOptions(request, runtime);
}

model RefundCdiBagRequest {
  instanceId?: string(name='InstanceId'),
  resourceOwnerId?: string(name='ResourceOwnerId'),
}

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

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

async function refundCdiBagWithOptions(request: RefundCdiBagRequest, runtime: Util.RuntimeOptions): RefundCdiBagResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('RefundCdiBag', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function refundCdiBag(request: RefundCdiBagRequest): RefundCdiBagResponse {
  var runtime = new Util.RuntimeOptions{};
  return refundCdiBagWithOptions(request, runtime);
}

model RefundCdiBaseBagRequest {
  instanceId?: string(name='InstanceId'),
  resourceOwnerId?: string(name='ResourceOwnerId'),
}

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

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

async function refundCdiBaseBagWithOptions(request: RefundCdiBaseBagRequest, runtime: Util.RuntimeOptions): RefundCdiBaseBagResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('RefundCdiBaseBag', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function refundCdiBaseBag(request: RefundCdiBaseBagRequest): RefundCdiBaseBagResponse {
  var runtime = new Util.RuntimeOptions{};
  return refundCdiBaseBagWithOptions(request, runtime);
}

model RefundWebSiteInstanceRequest {
  instanceId?: string(name='InstanceId'),
  resourceOwnerId?: string(name='ResourceOwnerId'),
}

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

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

async function refundWebSiteInstanceWithOptions(request: RefundWebSiteInstanceRequest, runtime: Util.RuntimeOptions): RefundWebSiteInstanceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('RefundWebSiteInstance', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function refundWebSiteInstance(request: RefundWebSiteInstanceRequest): RefundWebSiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return refundWebSiteInstanceWithOptions(request, runtime);
}

model RenewWebSiteInstanceRequest {
  clientToken?: string(name='ClientToken'),
  ownerId?: long(name='OwnerId'),
  commodityCode?: string(name='CommodityCode'),
  orderType?: string(name='OrderType'),
  duration?: int32(name='Duration'),
  pricingCycle?: string(name='PricingCycle'),
  instanceId?: string(name='InstanceId'),
  orderNum?: int32(name='OrderNum'),
}

model RenewWebSiteInstanceResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  instanceId?: string(name='InstanceId'),
  orderId?: string(name='OrderId'),
  instanceIds?: {
    string?: [ string ](name='String')
  }(name='InstanceIds'),
  code?: string(name='Code'),
}

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

async function renewWebSiteInstanceWithOptions(request: RenewWebSiteInstanceRequest, runtime: Util.RuntimeOptions): RenewWebSiteInstanceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('RenewWebSiteInstance', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function renewWebSiteInstance(request: RenewWebSiteInstanceRequest): RenewWebSiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return renewWebSiteInstanceWithOptions(request, runtime);
}

model SendVerifyCodeToEmailRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  email?: string(name='Email'),
}

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

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

async function sendVerifyCodeToEmailWithOptions(request: SendVerifyCodeToEmailRequest, runtime: Util.RuntimeOptions): SendVerifyCodeToEmailResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('SendVerifyCodeToEmail', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function sendVerifyCodeToEmail(request: SendVerifyCodeToEmailRequest): SendVerifyCodeToEmailResponse {
  var runtime = new Util.RuntimeOptions{};
  return sendVerifyCodeToEmailWithOptions(request, runtime);
}

model SendVerifyCodeToPhoneRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  phone?: string(name='Phone'),
}

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

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

async function sendVerifyCodeToPhoneWithOptions(request: SendVerifyCodeToPhoneRequest, runtime: Util.RuntimeOptions): SendVerifyCodeToPhoneResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('SendVerifyCodeToPhone', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function sendVerifyCodeToPhone(request: SendVerifyCodeToPhoneRequest): SendVerifyCodeToPhoneResponse {
  var runtime = new Util.RuntimeOptions{};
  return sendVerifyCodeToPhoneWithOptions(request, runtime);
}

model SendWebsiteFeedbackRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  feedback?: string(name='Feedback'),
  urls?: string(name='Urls'),
}

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

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

async function sendWebsiteFeedbackWithOptions(request: SendWebsiteFeedbackRequest, runtime: Util.RuntimeOptions): SendWebsiteFeedbackResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('SendWebsiteFeedback', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function sendWebsiteFeedback(request: SendWebsiteFeedbackRequest): SendWebsiteFeedbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return sendWebsiteFeedbackWithOptions(request, runtime);
}

model UpdateAppPackageRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  id?: long(name='Id'),
  packageUrl?: string(name='PackageUrl'),
  platform?: string(name='Platform'),
  debug?: boolean(name='Debug'),
}

model UpdateAppPackageResponseBody = {
  taskId?: string(name='TaskId'),
  requestId?: string(name='RequestId'),
}

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

async function updateAppPackageWithOptions(request: UpdateAppPackageRequest, runtime: Util.RuntimeOptions): UpdateAppPackageResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateAppPackage', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateAppPackage(request: UpdateAppPackageRequest): UpdateAppPackageResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateAppPackageWithOptions(request, runtime);
}

model UpdateAuditCallbackRequest {
  seed?: string(name='Seed'),
  callback?: string(name='Callback'),
  cryptType?: int32(name='CryptType'),
}

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

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

async function updateAuditCallbackWithOptions(request: UpdateAuditCallbackRequest, runtime: Util.RuntimeOptions): UpdateAuditCallbackResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateAuditCallback', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateAuditCallback(request: UpdateAuditCallbackRequest): UpdateAuditCallbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateAuditCallbackWithOptions(request, runtime);
}

model UpdateAuditRangeRequest {
  auditRange?: string(name='AuditRange'),
}

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

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

async function updateAuditRangeWithOptions(request: UpdateAuditRangeRequest, runtime: Util.RuntimeOptions): UpdateAuditRangeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateAuditRange', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateAuditRange(request: UpdateAuditRangeRequest): UpdateAuditRangeResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateAuditRangeWithOptions(request, runtime);
}

model UpdateAuditSettingRequest {
  sourceIp?: string(name='SourceIp'),
  seed?: string(name='Seed'),
  callback?: string(name='Callback'),
  auditRange?: string(name='AuditRange'),
}

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

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

async function updateAuditSettingWithOptions(request: UpdateAuditSettingRequest, runtime: Util.RuntimeOptions): UpdateAuditSettingResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateAuditSetting', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateAuditSetting(request: UpdateAuditSettingRequest): UpdateAuditSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateAuditSettingWithOptions(request, runtime);
}

model UpdateBizTypeRequest {
  bizTypeName?: string(name='BizTypeName'),
  description?: string(name='Description'),
}

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

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

async function updateBizTypeWithOptions(request: UpdateBizTypeRequest, runtime: Util.RuntimeOptions): UpdateBizTypeResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateBizType', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateBizType(request: UpdateBizTypeRequest): UpdateBizTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBizTypeWithOptions(request, runtime);
}

model UpdateBizTypeImageLibRequest {
  bizTypeName?: string(name='BizTypeName'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
  black?: string(name='Black'),
  review?: string(name='Review'),
  white?: string(name='White'),
}

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

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

async function updateBizTypeImageLibWithOptions(request: UpdateBizTypeImageLibRequest, runtime: Util.RuntimeOptions): UpdateBizTypeImageLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateBizTypeImageLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateBizTypeImageLib(request: UpdateBizTypeImageLibRequest): UpdateBizTypeImageLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBizTypeImageLibWithOptions(request, runtime);
}

model UpdateBizTypeSettingRequest {
  bizTypeName?: string(name='BizTypeName'),
  resourceType?: string(name='ResourceType'),
  porn?: string(name='Porn'),
  terrorism?: string(name='Terrorism'),
  antispam?: string(name='Antispam'),
  ad?: string(name='Ad'),
  live?: string(name='Live'),
}

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

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

async function updateBizTypeSettingWithOptions(request: UpdateBizTypeSettingRequest, runtime: Util.RuntimeOptions): UpdateBizTypeSettingResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateBizTypeSetting', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateBizTypeSetting(request: UpdateBizTypeSettingRequest): UpdateBizTypeSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBizTypeSettingWithOptions(request, runtime);
}

model UpdateBizTypeTextLibRequest {
  bizTypeName?: string(name='BizTypeName'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
  black?: string(name='Black'),
  review?: string(name='Review'),
  ignore?: string(name='Ignore'),
  white?: string(name='White'),
}

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

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

async function updateBizTypeTextLibWithOptions(request: UpdateBizTypeTextLibRequest, runtime: Util.RuntimeOptions): UpdateBizTypeTextLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateBizTypeTextLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateBizTypeTextLib(request: UpdateBizTypeTextLibRequest): UpdateBizTypeTextLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBizTypeTextLibWithOptions(request, runtime);
}

model UpdateCustomOcrTemplateRequest {
  id?: long(name='Id'),
  name?: string(name='Name'),
  referArea?: string(name='ReferArea'),
  recognizeArea?: string(name='RecognizeArea'),
}

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

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

async function updateCustomOcrTemplateWithOptions(request: UpdateCustomOcrTemplateRequest, runtime: Util.RuntimeOptions): UpdateCustomOcrTemplateResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateCustomOcrTemplate', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateCustomOcrTemplate(request: UpdateCustomOcrTemplateRequest): UpdateCustomOcrTemplateResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateCustomOcrTemplateWithOptions(request, runtime);
}

model UpdateImageLibRequest {
  sourceIp?: string(name='SourceIp'),
  id?: int32(name='Id'),
  name?: string(name='Name'),
  scene?: string(name='Scene'),
  category?: string(name='Category'),
  bizTypes?: string(name='BizTypes'),
  enable?: boolean(name='Enable'),
}

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

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

async function updateImageLibWithOptions(request: UpdateImageLibRequest, runtime: Util.RuntimeOptions): UpdateImageLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateImageLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateImageLib(request: UpdateImageLibRequest): UpdateImageLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateImageLibWithOptions(request, runtime);
}

model UpdateKeywordLibRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  id?: int32(name='Id'),
  name?: string(name='Name'),
  bizTypes?: string(name='BizTypes'),
  matchMode?: string(name='MatchMode'),
  enable?: boolean(name='Enable'),
}

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

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

async function updateKeywordLibWithOptions(request: UpdateKeywordLibRequest, runtime: Util.RuntimeOptions): UpdateKeywordLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateKeywordLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateKeywordLib(request: UpdateKeywordLibRequest): UpdateKeywordLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateKeywordLibWithOptions(request, runtime);
}

model UpdateNotificationSettingRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  realtimeMessageList?: string(name='RealtimeMessageList'),
  reminderModeList?: string(name='ReminderModeList'),
  scheduleMessageTime?: int32(name='ScheduleMessageTime'),
  scheduleMessageTimeZone?: int32(name='ScheduleMessageTimeZone'),
}

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

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

async function updateNotificationSettingWithOptions(request: UpdateNotificationSettingRequest, runtime: Util.RuntimeOptions): UpdateNotificationSettingResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateNotificationSetting', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateNotificationSetting(request: UpdateNotificationSettingRequest): UpdateNotificationSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateNotificationSettingWithOptions(request, runtime);
}

model UpdateOssCallbackSettingRequest {
  callbackUrl?: string(name='CallbackUrl'),
  scanCallback?: boolean(name='ScanCallback'),
  scanCallbackSuggestions?: string(name='ScanCallbackSuggestions'),
  auditCallback?: boolean(name='AuditCallback'),
  serviceModules?: string(name='ServiceModules'),
  callbackSeed?: string(name='CallbackSeed'),
}

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

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

async function updateOssCallbackSettingWithOptions(request: UpdateOssCallbackSettingRequest, runtime: Util.RuntimeOptions): UpdateOssCallbackSettingResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateOssCallbackSetting', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateOssCallbackSetting(request: UpdateOssCallbackSettingRequest): UpdateOssCallbackSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateOssCallbackSettingWithOptions(request, runtime);
}

model UpdateOssIncrementCheckSettingRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  bucketConfigList?: string(name='BucketConfigList'),
  imageScanLimit?: string(name='ImageScanLimit'),
  scanImageNoFileType?: boolean(name='ScanImageNoFileType'),
  imageSceneList?: string(name='ImageSceneList'),
  videoSceneList?: string(name='VideoSceneList'),
  imageAutoFreeze?: string(name='ImageAutoFreeze'),
  videoAutoFreezeSceneList?: string(name='VideoAutoFreezeSceneList'),
  videoFrameInterval?: int32(name='VideoFrameInterval'),
  videoMaxFrames?: int32(name='VideoMaxFrames'),
  videoMaxSize?: int32(name='VideoMaxSize'),
  autoFreezeType?: string(name='AutoFreezeType'),
  callbackId?: string(name='CallbackId'),
  audioSceneList?: string(name='AudioSceneList'),
  audioAntispamFreezeConfig?: string(name='AudioAntispamFreezeConfig'),
  audioMaxSize?: int32(name='AudioMaxSize'),
  audioAutoFreezeOpened?: boolean(name='AudioAutoFreezeOpened'),
}

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

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

async function updateOssIncrementCheckSettingWithOptions(request: UpdateOssIncrementCheckSettingRequest, runtime: Util.RuntimeOptions): UpdateOssIncrementCheckSettingResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateOssIncrementCheckSetting', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateOssIncrementCheckSetting(request: UpdateOssIncrementCheckSettingRequest): UpdateOssIncrementCheckSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateOssIncrementCheckSettingWithOptions(request, runtime);
}

model UpdateOssStockStatusRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  operation?: string(name='Operation'),
  startDate?: string(name='StartDate'),
  endDate?: string(name='EndDate'),
  bucketConfigList?: string(name='BucketConfigList'),
  resourceTypeList?: string(name='ResourceTypeList'),
  sceneList?: string(name='SceneList'),
  imageAutoFreeze?: string(name='ImageAutoFreeze'),
  videoAutoFreezeSceneList?: string(name='VideoAutoFreezeSceneList'),
  videoFrameInterval?: int32(name='VideoFrameInterval'),
  videoMaxFrames?: int32(name='VideoMaxFrames'),
  videoMaxSize?: int32(name='VideoMaxSize'),
  audioAutoFreezeSceneList?: string(name='AudioAutoFreezeSceneList'),
  audioMaxSize?: int32(name='AudioMaxSize'),
  autoFreezeType?: string(name='AutoFreezeType'),
}

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

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

async function updateOssStockStatusWithOptions(request: UpdateOssStockStatusRequest, runtime: Util.RuntimeOptions): UpdateOssStockStatusResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateOssStockStatus', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateOssStockStatus(request: UpdateOssStockStatusRequest): UpdateOssStockStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateOssStockStatusWithOptions(request, runtime);
}

model UpdateWebsiteInstanceRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  siteProtocol?: string(name='SiteProtocol'),
  instanceId?: string(name='InstanceId'),
  websiteScanInterval?: int32(name='WebsiteScanInterval'),
  domain?: string(name='Domain'),
  indexPageScanInterval?: int32(name='IndexPageScanInterval'),
  indexPage?: string(name='IndexPage'),
}

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

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

async function updateWebsiteInstanceWithOptions(request: UpdateWebsiteInstanceRequest, runtime: Util.RuntimeOptions): UpdateWebsiteInstanceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateWebsiteInstance', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateWebsiteInstance(request: UpdateWebsiteInstanceRequest): UpdateWebsiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateWebsiteInstanceWithOptions(request, runtime);
}

model UpdateWebsiteInstanceKeyUrlRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  urls?: string(name='Urls'),
  instanceId?: string(name='InstanceId'),
}

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

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

async function updateWebsiteInstanceKeyUrlWithOptions(request: UpdateWebsiteInstanceKeyUrlRequest, runtime: Util.RuntimeOptions): UpdateWebsiteInstanceKeyUrlResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateWebsiteInstanceKeyUrl', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateWebsiteInstanceKeyUrl(request: UpdateWebsiteInstanceKeyUrlRequest): UpdateWebsiteInstanceKeyUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateWebsiteInstanceKeyUrlWithOptions(request, runtime);
}

model UpdateWebsiteInstanceStatusRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  instanceId?: string(name='InstanceId'),
  status?: string(name='Status'),
}

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

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

async function updateWebsiteInstanceStatusWithOptions(request: UpdateWebsiteInstanceStatusRequest, runtime: Util.RuntimeOptions): UpdateWebsiteInstanceStatusResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateWebsiteInstanceStatus', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateWebsiteInstanceStatus(request: UpdateWebsiteInstanceStatusRequest): UpdateWebsiteInstanceStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateWebsiteInstanceStatusWithOptions(request, runtime);
}

model UpgradeCdiBaseBagRequest {
  clientToken?: string(name='ClientToken'),
  ownerId?: long(name='OwnerId'),
  commodityCode?: string(name='CommodityCode'),
  orderType?: string(name='OrderType'),
  instanceId?: string(name='InstanceId'),
  flowOutSpec?: int32(name='FlowOutSpec'),
}

model UpgradeCdiBaseBagResponseBody = {
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  instanceId?: string(name='InstanceId'),
  orderId?: string(name='OrderId'),
  code?: string(name='Code'),
}

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

async function upgradeCdiBaseBagWithOptions(request: UpgradeCdiBaseBagRequest, runtime: Util.RuntimeOptions): UpgradeCdiBaseBagResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpgradeCdiBaseBag', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function upgradeCdiBaseBag(request: UpgradeCdiBaseBagRequest): UpgradeCdiBaseBagResponse {
  var runtime = new Util.RuntimeOptions{};
  return upgradeCdiBaseBagWithOptions(request, runtime);
}

model UploadImageToLibRequest {
  sourceIp?: string(name='SourceIp'),
  imageLibId?: int32(name='ImageLibId'),
  images?: string(name='Images'),
  urls?: string(name='Urls'),
}

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

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

async function uploadImageToLibWithOptions(request: UploadImageToLibRequest, runtime: Util.RuntimeOptions): UploadImageToLibResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UploadImageToLib', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function uploadImageToLib(request: UploadImageToLibRequest): UploadImageToLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return uploadImageToLibWithOptions(request, runtime);
}

model VerifyCustomOcrTemplateRequest {
  id?: long(name='Id'),
  testImgUrl?: string(name='TestImgUrl'),
}

model VerifyCustomOcrTemplateResponseBody = {
  requestId?: string(name='RequestId'),
  imageUrl?: string(name='ImageUrl'),
  recognizeInfo?: string(name='RecognizeInfo'),
}

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

async function verifyCustomOcrTemplateWithOptions(request: VerifyCustomOcrTemplateRequest, runtime: Util.RuntimeOptions): VerifyCustomOcrTemplateResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('VerifyCustomOcrTemplate', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function verifyCustomOcrTemplate(request: VerifyCustomOcrTemplateRequest): VerifyCustomOcrTemplateResponse {
  var runtime = new Util.RuntimeOptions{};
  return verifyCustomOcrTemplateWithOptions(request, runtime);
}

model VerifyEmailRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  verifyCode?: string(name='VerifyCode'),
}

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

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

async function verifyEmailWithOptions(request: VerifyEmailRequest, runtime: Util.RuntimeOptions): VerifyEmailResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('VerifyEmail', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function verifyEmail(request: VerifyEmailRequest): VerifyEmailResponse {
  var runtime = new Util.RuntimeOptions{};
  return verifyEmailWithOptions(request, runtime);
}

model VerifyPhoneRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  phone?: string(name='Phone'),
  verifyCode?: string(name='VerifyCode'),
}

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

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

async function verifyPhoneWithOptions(request: VerifyPhoneRequest, runtime: Util.RuntimeOptions): VerifyPhoneResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('VerifyPhone', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function verifyPhone(request: VerifyPhoneRequest): VerifyPhoneResponse {
  var runtime = new Util.RuntimeOptions{};
  return verifyPhoneWithOptions(request, runtime);
}

model VerifyWebsiteInstanceRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  instanceId?: string(name='InstanceId'),
  verifyMethod?: string(name='VerifyMethod'),
}

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

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

async function verifyWebsiteInstanceWithOptions(request: VerifyWebsiteInstanceRequest, runtime: Util.RuntimeOptions): VerifyWebsiteInstanceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('VerifyWebsiteInstance', '2017-08-23', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function verifyWebsiteInstance(request: VerifyWebsiteInstanceRequest): VerifyWebsiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return verifyWebsiteInstanceWithOptions(request, runtime);
}

