lvwangwatermark-20210104/main.tea

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

import EndpointUtil;

extends OpenApi;

init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('lvwangwatermark', @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 AddAudioAsyncRequest {
  watermarkId?: string(name='WatermarkId'),
  urlList?: string(name='urlList'),
}

model AddAudioAsyncResponseBody = {
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      taskUid?: string(name='TaskUid'),
      dataId?: string(name='DataId'),
    }
  ](name='Data'),
}

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

async function addAudioAsyncWithOptions(request: AddAudioAsyncRequest, runtime: Util.RuntimeOptions): AddAudioAsyncResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('AddAudioAsync', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function addAudioAsync(request: AddAudioAsyncRequest): AddAudioAsyncResponse {
  var runtime = new Util.RuntimeOptions{};
  return addAudioAsyncWithOptions(request, runtime);
}

model AddDocAsyncRequest {
  watermarkId?: string(name='WatermarkId'),
  urlList?: string(name='urlList'),
}

model AddDocAsyncResponseBody = {
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      taskUid?: string(name='TaskUid'),
      dataId?: string(name='DataId'),
    }
  ](name='Data'),
}

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

async function addDocAsyncWithOptions(request: AddDocAsyncRequest, runtime: Util.RuntimeOptions): AddDocAsyncResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('AddDocAsync', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function addDocAsync(request: AddDocAsyncRequest): AddDocAsyncResponse {
  var runtime = new Util.RuntimeOptions{};
  return addDocAsyncWithOptions(request, runtime);
}

model AddImageAsyncRequest {
  watermarkId?: string(name='WatermarkId'),
  urlList?: string(name='urlList'),
}

model AddImageAsyncResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      taskUid?: string(name='TaskUid'),
      dataId?: string(name='DataId'),
    }
  ](name='Data'),
}

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

async function addImageAsyncWithOptions(request: AddImageAsyncRequest, runtime: Util.RuntimeOptions): AddImageAsyncResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('AddImageAsync', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function addImageAsync(request: AddImageAsyncRequest): AddImageAsyncResponse {
  var runtime = new Util.RuntimeOptions{};
  return addImageAsyncWithOptions(request, runtime);
}

model AddImageSyncRequest {
  watermarkId?: string(name='WatermarkId'),
  urlList?: string(name='urlList'),
}

model AddImageSyncResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      resultUrl?: string(name='ResultUrl'),
      dataId?: string(name='dataId'),
    }
  ](name='Data'),
}

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

async function addImageSyncWithOptions(request: AddImageSyncRequest, runtime: Util.RuntimeOptions): AddImageSyncResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('AddImageSync', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function addImageSync(request: AddImageSyncRequest): AddImageSyncResponse {
  var runtime = new Util.RuntimeOptions{};
  return addImageSyncWithOptions(request, runtime);
}

model AddVideoAsyncRequest {
  watermarkId?: string(name='WatermarkId'),
  vmType?: string(name='VmType'),
  urlList?: string(name='urlList'),
}

model AddVideoAsyncResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      taskUid?: string(name='TaskUid'),
      dataId?: string(name='DataId'),
    }
  ](name='Data'),
}

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

async function addVideoAsyncWithOptions(request: AddVideoAsyncRequest, runtime: Util.RuntimeOptions): AddVideoAsyncResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('AddVideoAsync', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function addVideoAsync(request: AddVideoAsyncRequest): AddVideoAsyncResponse {
  var runtime = new Util.RuntimeOptions{};
  return addVideoAsyncWithOptions(request, runtime);
}

model GetAudioAddRequest {
  taskId?: string(name='TaskId'),
}

model GetAudioAddResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      status?: string(name='Status'),
      sourceUrl?: string(name='SourceUrl'),
      resultUrl?: string(name='ResultUrl'),
      dataId?: string(name='DataId'),
      gmtModified?: long(name='GmtModified'),
      mediaType?: string(name='MediaType'),
      msg?: string(name='Msg'),
      taskUid?: string(name='TaskUid'),
      appId?: long(name='AppId'),
      gmtCreate?: long(name='GmtCreate'),
      optType?: string(name='OptType'),
      finishedTime?: long(name='FinishedTime'),
      id?: long(name='Id'),
    }
  ](name='Data'),
}

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

async function getAudioAddWithOptions(request: GetAudioAddRequest, runtime: Util.RuntimeOptions): GetAudioAddResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetAudioAdd', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getAudioAdd(request: GetAudioAddRequest): GetAudioAddResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAudioAddWithOptions(request, runtime);
}

model GetAudioAsyncRequest {
  appName?: string(name='AppName'),
  urlList?: string(name='urlList'),
  waterMarkType?: string(name='WaterMarkType'),
}

model GetAudioAsyncResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      taskUid?: string(name='TaskUid'),
      dataId?: string(name='DataId'),
    }
  ](name='Data'),
}

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

async function getAudioAsyncWithOptions(request: GetAudioAsyncRequest, runtime: Util.RuntimeOptions): GetAudioAsyncResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetAudioAsync', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getAudioAsync(request: GetAudioAsyncRequest): GetAudioAsyncResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAudioAsyncWithOptions(request, runtime);
}

model GetAudioExtractRequest {
  taskId?: string(name='TaskId'),
}

model GetAudioExtractResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      status?: string(name='Status'),
      sourceUrl?: string(name='SourceUrl'),
      waterMarkId?: string(name='WaterMarkId'),
      resultUrl?: string(name='ResultUrl'),
      dataId?: string(name='DataId'),
      gmtModified?: long(name='GmtModified'),
      mediaType?: string(name='MediaType'),
      msg?: string(name='Msg'),
      taskUid?: string(name='TaskUid'),
      appId?: long(name='AppId'),
      gmtCreate?: long(name='GmtCreate'),
      optType?: string(name='OptType'),
      finishedTime?: long(name='FinishedTime'),
      id?: long(name='Id'),
    }
  ](name='Data'),
}

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

async function getAudioExtractWithOptions(request: GetAudioExtractRequest, runtime: Util.RuntimeOptions): GetAudioExtractResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetAudioExtract', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getAudioExtract(request: GetAudioExtractRequest): GetAudioExtractResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAudioExtractWithOptions(request, runtime);
}

model GetAudioTraceRequest {
  appName?: string(name='AppName'),
  fileUid?: string(name='FileUid'),
  userInfoList?: string(name='userInfoList'),
}

model GetAudioTraceResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      resultUrl?: string(name='ResultUrl'),
      userInfo?: string(name='UserInfo'),
    }
  ](name='Data'),
}

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

async function getAudioTraceWithOptions(request: GetAudioTraceRequest, runtime: Util.RuntimeOptions): GetAudioTraceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetAudioTrace', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getAudioTrace(request: GetAudioTraceRequest): GetAudioTraceResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAudioTraceWithOptions(request, runtime);
}

model GetDocAddRequest {
  taskId?: string(name='TaskId'),
}

model GetDocAddResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      status?: string(name='Status'),
      sourceUrl?: string(name='SourceUrl'),
      resultUrl?: string(name='ResultUrl'),
      dataId?: string(name='DataId'),
      gmtModified?: long(name='GmtModified'),
      mediaType?: string(name='MediaType'),
      msg?: string(name='Msg'),
      taskUid?: string(name='TaskUid'),
      appId?: long(name='AppId'),
      gmtCreate?: long(name='GmtCreate'),
      optType?: string(name='OptType'),
      finishedTime?: long(name='FinishedTime'),
      id?: long(name='Id'),
    }
  ](name='Data'),
}

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

async function getDocAddWithOptions(request: GetDocAddRequest, runtime: Util.RuntimeOptions): GetDocAddResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetDocAdd', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getDocAdd(request: GetDocAddRequest): GetDocAddResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDocAddWithOptions(request, runtime);
}

model GetDocAsyncRequest {
  appName?: string(name='AppName'),
  urlList?: string(name='urlList'),
}

model GetDocAsyncResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      taskUid?: string(name='TaskUid'),
      dataId?: string(name='DataId'),
    }
  ](name='Data'),
}

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

async function getDocAsyncWithOptions(request: GetDocAsyncRequest, runtime: Util.RuntimeOptions): GetDocAsyncResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetDocAsync', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getDocAsync(request: GetDocAsyncRequest): GetDocAsyncResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDocAsyncWithOptions(request, runtime);
}

model GetDocExtractRequest {
  taskId?: string(name='TaskId'),
}

model GetDocExtractResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      status?: string(name='Status'),
      sourceUrl?: string(name='SourceUrl'),
      waterMarkId?: string(name='WaterMarkId'),
      resultUrl?: string(name='ResultUrl'),
      dataId?: string(name='DataId'),
      gmtModified?: long(name='GmtModified'),
      mediaType?: string(name='MediaType'),
      msg?: string(name='Msg'),
      taskUid?: string(name='TaskUid'),
      appId?: long(name='AppId'),
      gmtCreate?: long(name='GmtCreate'),
      optType?: string(name='OptType'),
      finishedTime?: long(name='FinishedTime'),
      id?: long(name='Id'),
    }
  ](name='Data'),
}

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

async function getDocExtractWithOptions(request: GetDocExtractRequest, runtime: Util.RuntimeOptions): GetDocExtractResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetDocExtract', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getDocExtract(request: GetDocExtractRequest): GetDocExtractResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDocExtractWithOptions(request, runtime);
}

model GetImageAsyncRequest {
  appName?: long(name='AppName'),
  urlList?: string(name='urlList'),
}

model GetImageAsyncResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      taskUid?: string(name='TaskUid'),
      dataId?: string(name='DataId'),
    }
  ](name='Data'),
}

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

async function getImageAsyncWithOptions(request: GetImageAsyncRequest, runtime: Util.RuntimeOptions): GetImageAsyncResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetImageAsync', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getImageAsync(request: GetImageAsyncRequest): GetImageAsyncResponse {
  var runtime = new Util.RuntimeOptions{};
  return getImageAsyncWithOptions(request, runtime);
}

model GetImageSyncRequest {
  appName?: string(name='AppName'),
  urlList?: string(name='urlList'),
}

model GetImageSyncResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      dataId?: string(name='dataId'),
      watermarkId?: string(name='WatermarkId'),
      metaFileUrl?: string(name='MetaFileUrl'),
    }
  ](name='Data'),
}

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

async function getImageSyncWithOptions(request: GetImageSyncRequest, runtime: Util.RuntimeOptions): GetImageSyncResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetImageSync', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getImageSync(request: GetImageSyncRequest): GetImageSyncResponse {
  var runtime = new Util.RuntimeOptions{};
  return getImageSyncWithOptions(request, runtime);
}

model GetQueryTraceFileRequest {
  taskId?: string(name='TaskId'),
}

model GetQueryTraceFileResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      status?: string(name='Status'),
      sourceUrl?: string(name='SourceUrl'),
      resultUrl?: string(name='ResultUrl'),
      dataId?: string(name='DataId'),
      gmtModified?: long(name='GmtModified'),
      mediaType?: string(name='MediaType'),
      msg?: string(name='Msg'),
      taskUid?: string(name='TaskUid'),
      appId?: long(name='AppId'),
      gmtCreate?: long(name='GmtCreate'),
      optType?: string(name='OptType'),
      finishedTime?: long(name='FinishedTime'),
      id?: long(name='Id'),
    }
  ](name='Data'),
}

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

async function getQueryTraceFileWithOptions(request: GetQueryTraceFileRequest, runtime: Util.RuntimeOptions): GetQueryTraceFileResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetQueryTraceFile', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getQueryTraceFile(request: GetQueryTraceFileRequest): GetQueryTraceFileResponse {
  var runtime = new Util.RuntimeOptions{};
  return getQueryTraceFileWithOptions(request, runtime);
}

model GetVideoAddRequest {
  taskId?: string(name='TaskId'),
}

model GetVideoAddResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      status?: string(name='Status'),
      sourceUrl?: string(name='SourceUrl'),
      resultUrl?: string(name='ResultUrl'),
      dataId?: string(name='DataId'),
      gmtModified?: long(name='GmtModified'),
      mediaType?: string(name='MediaType'),
      msg?: string(name='Msg'),
      taskUid?: string(name='TaskUid'),
      appId?: long(name='AppId'),
      gmtCreate?: long(name='GmtCreate'),
      optType?: string(name='OptType'),
      finishedTime?: long(name='FinishedTime'),
      id?: long(name='Id'),
    }
  ](name='Data'),
}

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

async function getVideoAddWithOptions(request: GetVideoAddRequest, runtime: Util.RuntimeOptions): GetVideoAddResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetVideoAdd', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getVideoAdd(request: GetVideoAddRequest): GetVideoAddResponse {
  var runtime = new Util.RuntimeOptions{};
  return getVideoAddWithOptions(request, runtime);
}

model GetVideoAsyncRequest {
  appName?: string(name='AppName'),
  urlList?: string(name='urlList'),
  waterMarkType?: string(name='WaterMarkType'),
  vmType?: string(name='VmType'),
}

model GetVideoAsyncResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      taskUid?: string(name='TaskUid'),
      dataId?: string(name='DataId'),
    }
  ](name='Data'),
}

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

async function getVideoAsyncWithOptions(request: GetVideoAsyncRequest, runtime: Util.RuntimeOptions): GetVideoAsyncResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetVideoAsync', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getVideoAsync(request: GetVideoAsyncRequest): GetVideoAsyncResponse {
  var runtime = new Util.RuntimeOptions{};
  return getVideoAsyncWithOptions(request, runtime);
}

model GetVideoExtractRequest {
  taskId?: string(name='TaskId'),
}

model GetVideoExtractResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      status?: string(name='Status'),
      sourceUrl?: string(name='SourceUrl'),
      waterMarkId?: string(name='WaterMarkId'),
      resultUrl?: string(name='ResultUrl'),
      dataId?: string(name='DataId'),
      gmtModified?: long(name='GmtModified'),
      mediaType?: string(name='MediaType'),
      msg?: string(name='Msg'),
      taskUid?: string(name='TaskUid'),
      appId?: long(name='AppId'),
      gmtCreate?: long(name='GmtCreate'),
      optType?: string(name='OptType'),
      finishedTime?: long(name='FinishedTime'),
      id?: long(name='Id'),
    }
  ](name='Data'),
}

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

async function getVideoExtractWithOptions(request: GetVideoExtractRequest, runtime: Util.RuntimeOptions): GetVideoExtractResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetVideoExtract', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getVideoExtract(request: GetVideoExtractRequest): GetVideoExtractResponse {
  var runtime = new Util.RuntimeOptions{};
  return getVideoExtractWithOptions(request, runtime);
}

model GetVideoTraceRequest {
  appName?: string(name='AppName'),
  fileUid?: string(name='FileUid'),
  userInfoList?: string(name='userInfoList'),
  fileType?: string(name='FileType'),
}

model GetVideoTraceResponseBody = {
  requestId?: string(name='RequestId'),
  data?: [ 
    {
      taskUid?: string(name='TaskUid'),
      resultUrl?: string(name='ResultUrl'),
      userInfo?: string(name='UserInfo'),
      fileUid?: string(name='FileUid'),
    }
  ](name='Data'),
}

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

async function getVideoTraceWithOptions(request: GetVideoTraceRequest, runtime: Util.RuntimeOptions): GetVideoTraceResponse {
  Util.validateModel(request);
  var req = new OpenApi.OpenApiRequest{ 
    body = Util.toMap(request),
  };
  return doRPCRequest('GetVideoTrace', '2021-01-04', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}

async function getVideoTrace(request: GetVideoTraceRequest): GetVideoTraceResponse {
  var runtime = new Util.RuntimeOptions{};
  return getVideoTraceWithOptions(request, runtime);
}