afs-20180112/main.tea

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

import EndpointUtil;

extends OpenApi;

init(config: OpenApi.Config){
  super(config);
  @endpointRule = 'regional';
  
  @endpointMap = {
    ap-northeast-1 = 'afs.aliyuncs.com',
    ap-northeast-2-pop = 'afs.aliyuncs.com',
    ap-south-1 = 'afs.aliyuncs.com',
    ap-southeast-1 = 'afs.aliyuncs.com',
    ap-southeast-2 = 'afs.aliyuncs.com',
    ap-southeast-3 = 'afs.aliyuncs.com',
    ap-southeast-5 = 'afs.aliyuncs.com',
    cn-beijing = 'afs.aliyuncs.com',
    cn-beijing-finance-1 = 'afs.aliyuncs.com',
    cn-beijing-finance-pop = 'afs.aliyuncs.com',
    cn-beijing-gov-1 = 'afs.aliyuncs.com',
    cn-beijing-nu16-b01 = 'afs.aliyuncs.com',
    cn-chengdu = 'afs.aliyuncs.com',
    cn-edge-1 = 'afs.aliyuncs.com',
    cn-fujian = 'afs.aliyuncs.com',
    cn-haidian-cm12-c01 = 'afs.aliyuncs.com',
    cn-hangzhou-bj-b01 = 'afs.aliyuncs.com',
    cn-hangzhou-finance = 'afs.aliyuncs.com',
    cn-hangzhou-internal-prod-1 = 'afs.aliyuncs.com',
    cn-hangzhou-internal-test-1 = 'afs.aliyuncs.com',
    cn-hangzhou-internal-test-2 = 'afs.aliyuncs.com',
    cn-hangzhou-internal-test-3 = 'afs.aliyuncs.com',
    cn-hangzhou-test-306 = 'afs.aliyuncs.com',
    cn-hongkong = 'afs.aliyuncs.com',
    cn-hongkong-finance-pop = 'afs.aliyuncs.com',
    cn-huhehaote = 'afs.aliyuncs.com',
    cn-north-2-gov-1 = 'afs.aliyuncs.com',
    cn-qingdao = 'afs.aliyuncs.com',
    cn-qingdao-nebula = 'afs.aliyuncs.com',
    cn-shanghai = 'afs.aliyuncs.com',
    cn-shanghai-et15-b01 = 'afs.aliyuncs.com',
    cn-shanghai-et2-b01 = 'afs.aliyuncs.com',
    cn-shanghai-finance-1 = 'afs.aliyuncs.com',
    cn-shanghai-inner = 'afs.aliyuncs.com',
    cn-shanghai-internal-test-1 = 'afs.aliyuncs.com',
    cn-shenzhen = 'afs.aliyuncs.com',
    cn-shenzhen-finance-1 = 'afs.aliyuncs.com',
    cn-shenzhen-inner = 'afs.aliyuncs.com',
    cn-shenzhen-st4-d01 = 'afs.aliyuncs.com',
    cn-shenzhen-su18-b01 = 'afs.aliyuncs.com',
    cn-wuhan = 'afs.aliyuncs.com',
    cn-yushanfang = 'afs.aliyuncs.com',
    cn-zhangbei-na61-b01 = 'afs.aliyuncs.com',
    cn-zhangjiakou = 'afs.aliyuncs.com',
    cn-zhangjiakou-na62-a01 = 'afs.aliyuncs.com',
    cn-zhengzhou-nebula-1 = 'afs.aliyuncs.com',
    eu-central-1 = 'afs.aliyuncs.com',
    eu-west-1 = 'afs.aliyuncs.com',
    eu-west-1-oxs = 'afs.aliyuncs.com',
    me-east-1 = 'afs.aliyuncs.com',
    rus-west-1-pop = 'afs.aliyuncs.com',
    us-east-1 = 'afs.aliyuncs.com',
    us-west-1 = 'afs.aliyuncs.com',
  };
  checkConfig(config);
  @endpoint = getEndpoint('afs', @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 AnalyzeNvcRequest {
  sourceIp?: string(name='SourceIp'),
  scoreJsonStr?: string(name='ScoreJsonStr'),
  data?: string(name='Data'),
}

model AnalyzeNvcResponseBody = {
  requestId?: string(name='RequestId'),
  bizCode?: string(name='BizCode'),
}

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

async function analyzeNvcWithOptions(request: AnalyzeNvcRequest, runtime: Util.RuntimeOptions): AnalyzeNvcResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('AnalyzeNvc', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function analyzeNvc(request: AnalyzeNvcRequest): AnalyzeNvcResponse {
  var runtime = new Util.RuntimeOptions{};
  return analyzeNvcWithOptions(request, runtime);
}

model AuthenticateSigRequest {
  sourceIp?: string(name='SourceIp'),
  sessionId?: string(name='SessionId'),
  appKey?: string(name='AppKey'),
  sig?: string(name='Sig'),
  token?: string(name='Token'),
  scene?: string(name='Scene'),
  remoteIp?: string(name='RemoteIp'),
}

model AuthenticateSigResponseBody = {
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  riskLevel?: string(name='RiskLevel'),
  code?: int32(name='Code'),
  detail?: string(name='Detail'),
}

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

async function authenticateSigWithOptions(request: AuthenticateSigRequest, runtime: Util.RuntimeOptions): AuthenticateSigResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('AuthenticateSig', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function authenticateSig(request: AuthenticateSigRequest): AuthenticateSigResponse {
  var runtime = new Util.RuntimeOptions{};
  return authenticateSigWithOptions(request, runtime);
}

model ConfigurationStyleRequest {
  sourceIp?: string(name='SourceIp'),
  applyType?: string(name='ApplyType'),
  scene?: string(name='Scene'),
  configurationMethod?: string(name='ConfigurationMethod'),
  refExtId?: string(name='RefExtId'),
}

model ConfigurationStyleResponseBody = {
  codeData?: {
    nodeJs?: string(name='NodeJs'),
    javaUrl?: string(name='JavaUrl'),
    python?: string(name='Python'),
    java?: string(name='Java'),
    nodeJsUrl?: string(name='NodeJsUrl'),
    pythonUrl?: string(name='PythonUrl'),
    html?: string(name='Html'),
    phpUrl?: string(name='PhpUrl'),
    netUrl?: string(name='NetUrl'),
    php?: string(name='Php'),
    net?: string(name='Net'),
  }(name='CodeData'),
  requestId?: string(name='RequestId'),
  bizCode?: string(name='BizCode'),
}

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

async function configurationStyleWithOptions(request: ConfigurationStyleRequest, runtime: Util.RuntimeOptions): ConfigurationStyleResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('ConfigurationStyle', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function configurationStyle(request: ConfigurationStyleRequest): ConfigurationStyleResponse {
  var runtime = new Util.RuntimeOptions{};
  return configurationStyleWithOptions(request, runtime);
}

model CreateConfigurationRequest {
  sourceIp?: string(name='SourceIp'),
  configurationName?: string(name='ConfigurationName'),
  applyType?: string(name='ApplyType'),
  scene?: string(name='Scene'),
  maxPV?: string(name='MaxPV'),
  configurationMethod?: string(name='ConfigurationMethod'),
}

model CreateConfigurationResponseBody = {
  refExtId?: string(name='RefExtId'),
  requestId?: string(name='RequestId'),
  bizCode?: string(name='BizCode'),
}

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

async function createConfigurationWithOptions(request: CreateConfigurationRequest, runtime: Util.RuntimeOptions): CreateConfigurationResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('CreateConfiguration', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function createConfiguration(request: CreateConfigurationRequest): CreateConfigurationResponse {
  var runtime = new Util.RuntimeOptions{};
  return createConfigurationWithOptions(request, runtime);
}

model DescribeAfsConfigNameRequest {
  sourceIp?: string(name='SourceIp'),
  productName?: string(name='ProductName'),
}

model DescribeAfsConfigNameResponseBody = {
  requestId?: string(name='RequestId'),
  configNames?: [ 
    {
      configName?: string(name='ConfigName'),
      appKey?: string(name='AppKey'),
      refExtId?: string(name='RefExtId'),
      aliUid?: string(name='AliUid'),
      scene?: string(name='Scene'),
    }
  ](name='ConfigNames'),
  bizCode?: string(name='BizCode'),
  hasData?: boolean(name='HasData'),
}

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

async function describeAfsConfigNameWithOptions(request: DescribeAfsConfigNameRequest, runtime: Util.RuntimeOptions): DescribeAfsConfigNameResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeAfsConfigName', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeAfsConfigName(request: DescribeAfsConfigNameRequest): DescribeAfsConfigNameResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAfsConfigNameWithOptions(request, runtime);
}

model DescribeAfsOneConfDataRequest {
  sourceIp?: string(name='SourceIp'),
  appKey?: string(name='AppKey'),
  scene?: string(name='Scene'),
  productName?: string(name='ProductName'),
}

model DescribeAfsOneConfDataResponseBody = {
  requestId?: string(name='RequestId'),
  icOneConfDatas?: [ 
    {
      icSigCnt?: long(name='IcSigCnt'),
      icBlockCnt?: long(name='IcBlockCnt'),
      tableDate?: string(name='TableDate'),
      icVerifyCnt?: long(name='IcVerifyCnt'),
      icSecVerifyCnt?: long(name='IcSecVerifyCnt'),
      icInitCnt?: long(name='IcInitCnt'),
      icNoActionCnt?: long(name='IcNoActionCnt'),
    }
  ](name='IcOneConfDatas'),
  ncOneConfDatas?: [ 
    {
      tableDate?: string(name='TableDate'),
      ncSigCnt?: long(name='NcSigCnt'),
      ncVerifyCnt?: long(name='NcVerifyCnt'),
      ncNoActionCnt?: long(name='NcNoActionCnt'),
      ncVerifyBlockCnt?: long(name='NcVerifyBlockCnt'),
      ncInitCnt?: int32(name='NcInitCnt'),
      ncSigBlockCnt?: long(name='NcSigBlockCnt'),
    }
  ](name='NcOneConfDatas'),
  nvcOneConfDatas?: [ 
    {
      nvcNoActionCnt?: long(name='NvcNoActionCnt'),
      nvcSecVerifyCnt?: long(name='NvcSecVerifyCnt'),
      tableDate?: string(name='TableDate'),
      nvcVerifyCnt?: long(name='NvcVerifyCnt'),
      nvcBlockCnt?: long(name='NvcBlockCnt'),
      nvcInitCnt?: long(name='NvcInitCnt'),
    }
  ](name='NvcOneConfDatas'),
  bizCode?: string(name='BizCode'),
  hasData?: boolean(name='HasData'),
}

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

async function describeAfsOneConfDataWithOptions(request: DescribeAfsOneConfDataRequest, runtime: Util.RuntimeOptions): DescribeAfsOneConfDataResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeAfsOneConfData', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeAfsOneConfData(request: DescribeAfsOneConfDataRequest): DescribeAfsOneConfDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAfsOneConfDataWithOptions(request, runtime);
}

model DescribeAfsTotalConfDataRequest {
  sourceIp?: string(name='SourceIp'),
  productName?: string(name='ProductName'),
}

model DescribeAfsTotalConfDataResponseBody = {
  requestId?: string(name='RequestId'),
  icTotalConfSigDatas?: [ 
    {
      time?: string(name='Time'),
      value?: long(name='Value'),
      category?: string(name='Category'),
    }
  ](name='IcTotalConfSigDatas'),
  nvcTotalConfSecVerifyDatas?: [ 
    {
      time?: string(name='Time'),
      value?: long(name='Value'),
      category?: string(name='Category'),
    }
  ](name='NvcTotalConfSecVerifyDatas'),
  icTotalConfVerifyDatas?: [ 
    {
      time?: string(name='Time'),
      value?: long(name='Value'),
      category?: string(name='Category'),
    }
  ](name='IcTotalConfVerifyDatas'),
  nvcTotalConfVerifyDatas?: [ 
    {
      time?: string(name='Time'),
      value?: long(name='Value'),
      category?: string(name='Category'),
    }
  ](name='NvcTotalConfVerifyDatas'),
  icTotalConfSecVerifyDatas?: [ 
    {
      time?: string(name='Time'),
      value?: long(name='Value'),
      category?: string(name='Category'),
    }
  ](name='IcTotalConfSecVerifyDatas'),
  ncTotalConfBlockDatas?: [ 
    {
      time?: string(name='Time'),
      value?: long(name='Value'),
      category?: string(name='Category'),
    }
  ](name='NcTotalConfBlockDatas'),
  icTotalConfBlockDatas?: [ 
    {
      time?: string(name='Time'),
      value?: long(name='Value'),
      category?: string(name='Category'),
    }
  ](name='IcTotalConfBlockDatas'),
  ncTotalConfSigDatas?: [ 
    {
      time?: string(name='Time'),
      value?: long(name='Value'),
      category?: string(name='Category'),
    }
  ](name='NcTotalConfSigDatas'),
  bizCode?: string(name='BizCode'),
  hasData?: boolean(name='HasData'),
  ncTotalConfVerifyDatas?: [ 
    {
      time?: string(name='Time'),
      value?: long(name='Value'),
      category?: string(name='Category'),
    }
  ](name='NcTotalConfVerifyDatas'),
}

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

async function describeAfsTotalConfDataWithOptions(request: DescribeAfsTotalConfDataRequest, runtime: Util.RuntimeOptions): DescribeAfsTotalConfDataResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeAfsTotalConfData', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeAfsTotalConfData(request: DescribeAfsTotalConfDataRequest): DescribeAfsTotalConfDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAfsTotalConfDataWithOptions(request, runtime);
}

model DescribeAfsVerifySigDataRequest {
  sourceIp?: string(name='SourceIp'),
  appKey?: string(name='AppKey'),
  scene?: string(name='Scene'),
  productName?: string(name='ProductName'),
}

model DescribeAfsVerifySigDataResponseBody = {
  nvcCodeDatas?: [ 
    {
      time?: string(name='Time'),
      nvcCode400?: long(name='NvcCode400'),
      nvcCode200?: long(name='NvcCode200'),
      nvcCode800?: long(name='NvcCode800'),
      nvcCode600?: long(name='NvcCode600'),
    }
  ](name='NvcCodeDatas'),
  nvcSecDatas?: [ 
    {
      time?: string(name='Time'),
      nvcSecBlock?: long(name='NvcSecBlock'),
      nvcSecPass?: long(name='NvcSecPass'),
    }
  ](name='NvcSecDatas'),
  icVerifyDatas?: [ 
    {
      icSigCnt?: long(name='IcSigCnt'),
      time?: string(name='Time'),
      icBlockCnt?: long(name='IcBlockCnt'),
      icSecVerifyCnt?: long(name='IcSecVerifyCnt'),
      icVerifyCnt?: long(name='IcVerifyCnt'),
    }
  ](name='IcVerifyDatas'),
  requestId?: string(name='RequestId'),
  ncVerifyDatas?: [ 
    {
      time?: string(name='Time'),
      ncVerifyPass?: long(name='NcVerifyPass'),
      ncVerifyBlock?: long(name='NcVerifyBlock'),
    }
  ](name='NcVerifyDatas'),
  nvcVerifyDatas?: [ 
    {
      time?: string(name='Time'),
      nvcSecVerifyCnt?: long(name='NvcSecVerifyCnt'),
      nvcVerifyCnt?: long(name='NvcVerifyCnt'),
    }
  ](name='NvcVerifyDatas'),
  icSecVerifyDatas?: [ 
    {
      icSecBlock?: long(name='IcSecBlock'),
      time?: string(name='Time'),
      icSecPass?: long(name='IcSecPass'),
    }
  ](name='IcSecVerifyDatas'),
  ncSigDatas?: [ 
    {
      time?: string(name='Time'),
      ncSigBlock?: long(name='NcSigBlock'),
      ncSigPass?: long(name='NcSigPass'),
    }
  ](name='NcSigDatas'),
  bizCode?: string(name='BizCode'),
  hasData?: boolean(name='HasData'),
}

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

async function describeAfsVerifySigDataWithOptions(request: DescribeAfsVerifySigDataRequest, runtime: Util.RuntimeOptions): DescribeAfsVerifySigDataResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeAfsVerifySigData', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeAfsVerifySigData(request: DescribeAfsVerifySigDataRequest): DescribeAfsVerifySigDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAfsVerifySigDataWithOptions(request, runtime);
}

model DescribeCaptchaDayRequest {
  sourceIp?: string(name='SourceIp'),
  configName?: string(name='ConfigName'),
  type?: string(name='Type'),
  time?: string(name='Time'),
  refExtId?: string(name='RefExtId'),
}

model DescribeCaptchaDayResponseBody = {
  captchaDay?: {
    checkTested?: int32(name='CheckTested'),
    direcetStrategyInterception?: int32(name='DirecetStrategyInterception'),
    maliciousFlow?: int32(name='MaliciousFlow'),
    pass?: int32(name='Pass'),
    legalSign?: int32(name='LegalSign'),
    uncheckTested?: int32(name='UncheckTested'),
    askForVerify?: int32(name='AskForVerify'),
    init?: int32(name='Init'),
    twiceVerify?: int32(name='TwiceVerify'),
  }(name='CaptchaDay'),
  requestId?: string(name='RequestId'),
  bizCode?: string(name='BizCode'),
  hasData?: boolean(name='HasData'),
}

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

async function describeCaptchaDayWithOptions(request: DescribeCaptchaDayRequest, runtime: Util.RuntimeOptions): DescribeCaptchaDayResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeCaptchaDay', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeCaptchaDay(request: DescribeCaptchaDayRequest): DescribeCaptchaDayResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeCaptchaDayWithOptions(request, runtime);
}

model DescribeCaptchaIpCityRequest {
  sourceIp?: string(name='SourceIp'),
  configName?: string(name='ConfigName'),
  type?: string(name='Type'),
  time?: string(name='Time'),
  refExtId?: string(name='RefExtId'),
}

model DescribeCaptchaIpCityResponseBody = {
  captchaIps?: [ 
    {
      value?: int32(name='Value'),
      ip?: string(name='Ip'),
    }
  ](name='CaptchaIps'),
  captchaCities?: [ 
    {
      pv?: int32(name='Pv'),
      lng?: string(name='Lng'),
      lat?: string(name='Lat'),
      location?: string(name='Location'),
    }
  ](name='CaptchaCities'),
  requestId?: string(name='RequestId'),
  bizCode?: string(name='BizCode'),
  hasData?: boolean(name='HasData'),
}

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

async function describeCaptchaIpCityWithOptions(request: DescribeCaptchaIpCityRequest, runtime: Util.RuntimeOptions): DescribeCaptchaIpCityResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeCaptchaIpCity', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeCaptchaIpCity(request: DescribeCaptchaIpCityRequest): DescribeCaptchaIpCityResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeCaptchaIpCityWithOptions(request, runtime);
}

model DescribeCaptchaMinRequest {
  sourceIp?: string(name='SourceIp'),
  configName?: string(name='ConfigName'),
  type?: string(name='Type'),
  time?: string(name='Time'),
  refExtId?: string(name='RefExtId'),
}

model DescribeCaptchaMinResponseBody = {
  requestId?: string(name='RequestId'),
  captchaMins?: [ 
    {
      time?: string(name='Time'),
      pass?: string(name='Pass'),
      interception?: string(name='Interception'),
    }
  ](name='CaptchaMins'),
  bizCode?: string(name='BizCode'),
  hasData?: boolean(name='HasData'),
}

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

async function describeCaptchaMinWithOptions(request: DescribeCaptchaMinRequest, runtime: Util.RuntimeOptions): DescribeCaptchaMinResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeCaptchaMin', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeCaptchaMin(request: DescribeCaptchaMinRequest): DescribeCaptchaMinResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeCaptchaMinWithOptions(request, runtime);
}

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

model DescribeCaptchaOrderResponseBody = {
  requestId?: string(name='RequestId'),
  bizCode?: string(name='BizCode'),
}

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

async function describeCaptchaOrderWithOptions(request: DescribeCaptchaOrderRequest, runtime: Util.RuntimeOptions): DescribeCaptchaOrderResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeCaptchaOrder', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeCaptchaOrder(request: DescribeCaptchaOrderRequest): DescribeCaptchaOrderResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeCaptchaOrderWithOptions(request, runtime);
}

model DescribeCaptchaRiskRequest {
  sourceIp?: string(name='SourceIp'),
  configName?: string(name='ConfigName'),
  time?: string(name='Time'),
  refExtId?: string(name='RefExtId'),
}

model DescribeCaptchaRiskResponseBody = {
  requestId?: string(name='RequestId'),
  numOfLastMonth?: int32(name='NumOfLastMonth'),
  riskLevel?: string(name='RiskLevel'),
  numOfThisMonth?: int32(name='NumOfThisMonth'),
  bizCode?: string(name='BizCode'),
}

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

async function describeCaptchaRiskWithOptions(request: DescribeCaptchaRiskRequest, runtime: Util.RuntimeOptions): DescribeCaptchaRiskResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeCaptchaRisk', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeCaptchaRisk(request: DescribeCaptchaRiskRequest): DescribeCaptchaRiskResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeCaptchaRiskWithOptions(request, runtime);
}

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

model DescribeConfigNameResponseBody = {
  requestId?: string(name='RequestId'),
  configNames?: [ 
    {
      configName?: string(name='ConfigName'),
      refExtId?: string(name='RefExtId'),
      aliUid?: string(name='AliUid'),
    }
  ](name='ConfigNames'),
  hasConfig?: boolean(name='HasConfig'),
  bizCode?: string(name='BizCode'),
}

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

async function describeConfigNameWithOptions(request: DescribeConfigNameRequest, runtime: Util.RuntimeOptions): DescribeConfigNameResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeConfigName', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeConfigName(request: DescribeConfigNameRequest): DescribeConfigNameResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeConfigNameWithOptions(request, runtime);
}

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

model DescribeEarlyWarningResponseBody = {
  requestId?: string(name='RequestId'),
  hasWarning?: boolean(name='HasWarning'),
  earlyWarnings?: [ 
    {
      frequency?: string(name='Frequency'),
      timeBegin?: string(name='TimeBegin'),
      timeEnd?: string(name='TimeEnd'),
      channel?: string(name='Channel'),
      warnOpen?: boolean(name='WarnOpen'),
      title?: string(name='Title'),
      content?: string(name='Content'),
      timeOpen?: boolean(name='TimeOpen'),
    }
  ](name='EarlyWarnings'),
  bizCode?: string(name='BizCode'),
}

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

async function describeEarlyWarningWithOptions(request: DescribeEarlyWarningRequest, runtime: Util.RuntimeOptions): DescribeEarlyWarningResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeEarlyWarning', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeEarlyWarning(request: DescribeEarlyWarningRequest): DescribeEarlyWarningResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeEarlyWarningWithOptions(request, runtime);
}

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

model DescribeOrderInfoResponseBody = {
  orderLevel?: string(name='OrderLevel'),
  requestId?: string(name='RequestId'),
  num?: string(name='Num'),
  endDate?: string(name='EndDate'),
  bizCode?: string(name='BizCode'),
  beginDate?: string(name='BeginDate'),
}

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

async function describeOrderInfoWithOptions(request: DescribeOrderInfoRequest, runtime: Util.RuntimeOptions): DescribeOrderInfoResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribeOrderInfo', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describeOrderInfo(request: DescribeOrderInfoRequest): DescribeOrderInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOrderInfoWithOptions(request, runtime);
}

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

model DescribePersonMachineListResponseBody = {
  personMachineRes?: {
    personMachines?: [ 
      {
        configurationName?: string(name='ConfigurationName'),
        configurationMethod?: string(name='ConfigurationMethod'),
        extId?: string(name='ExtId'),
        applyType?: string(name='ApplyType'),
        lastUpdate?: string(name='LastUpdate'),
        scene?: string(name='Scene'),
        sceneOriginal?: string(name='SceneOriginal'),
        appkey?: string(name='Appkey'),
      }
    ](name='PersonMachines'),
    hasConfiguration?: string(name='HasConfiguration'),
  }(name='PersonMachineRes'),
  requestId?: string(name='RequestId'),
  bizCode?: string(name='BizCode'),
}

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

async function describePersonMachineListWithOptions(request: DescribePersonMachineListRequest, runtime: Util.RuntimeOptions): DescribePersonMachineListResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('DescribePersonMachineList', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function describePersonMachineList(request: DescribePersonMachineListRequest): DescribePersonMachineListResponse {
  var runtime = new Util.RuntimeOptions{};
  return describePersonMachineListWithOptions(request, runtime);
}

model SetEarlyWarningRequest {
  sourceIp?: string(name='SourceIp'),
  warnOpen?: boolean(name='WarnOpen'),
  channel?: string(name='Channel'),
  frequency?: string(name='Frequency'),
  timeOpen?: boolean(name='TimeOpen'),
  timeBegin?: string(name='TimeBegin'),
  timeEnd?: string(name='TimeEnd'),
  title?: string(name='Title'),
}

model SetEarlyWarningResponseBody = {
  requestId?: string(name='RequestId'),
  bizCode?: string(name='BizCode'),
}

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

async function setEarlyWarningWithOptions(request: SetEarlyWarningRequest, runtime: Util.RuntimeOptions): SetEarlyWarningResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('SetEarlyWarning', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function setEarlyWarning(request: SetEarlyWarningRequest): SetEarlyWarningResponse {
  var runtime = new Util.RuntimeOptions{};
  return setEarlyWarningWithOptions(request, runtime);
}

model UpdateConfigNameRequest {
  sourceIp?: string(name='SourceIp'),
  lang?: string(name='Lang'),
  refExtId?: string(name='RefExtId'),
  configName?: string(name='ConfigName'),
}

model UpdateConfigNameResponseBody = {
  requestId?: string(name='RequestId'),
  bizCode?: string(name='BizCode'),
}

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

async function updateConfigNameWithOptions(request: UpdateConfigNameRequest, runtime: Util.RuntimeOptions): UpdateConfigNameResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('UpdateConfigName', '2018-01-12', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function updateConfigName(request: UpdateConfigNameRequest): UpdateConfigNameResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateConfigNameWithOptions(request, runtime);
}